Datasets:

VatsaDev
/

codegolf

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 14k rows

text stringlengths 180 608k
[Question] [ Make a Quine. Seems easy right? Well this quine must output itself plus its first character, which then outputs itself plus its second character, and so on. This way the quine should in several generations output two copies. Example: Lets your code be `x`. Running it should output `x + x[:1]`. Running the resulting program should output `x + x[:2]` and so on... If your code was `foobar`, running this should output `foobarf`. Running this should output `foobarfo`. And so on and so forth following this pattern: ``` foobar foobarf foobarfo foobarfoo foobarfoob foobarfooba foobarfoobar foobarfoobarf ``` Your Program must be longer than 2 Bytes and must output only ONE extra character of its own code each iteration. [Answer] # [Zsh](https://www.zsh.org/), ~~110~~ ~~108~~ 100 bytes ``` a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50} a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50} ``` [Try it online!](https://tio.run/nexus/zsh#@59om2CjZpBgY6OubmNjU2KdZKtSnWhlYGVqUGtdUJSZV5KmoJIEhGBBXaAoF@k6/v8HAA "Zsh – TIO Nexus") So it is possible. ### Explanation ``` a=`<&0`<<''<<<t; # Set A to everything following this line, until eof or # an empty line (which never happens before eof) encountered. # A "t" is appended to prevent automatic trimming of newlines. b=${a:0:50}; # Set B to the first line. printf $b$b${a:0:-50} # Print two copies of B and # A with 50 trailing characters removed. ``` [Answer] # R, 289 bytes ``` s<-c("s<-", "i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#") i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))# ``` credit to [this quine](https://github.com/MakeNowJust/quine/blob/master/quine.R) for inspiration. Only works if run in the same R environment as the previous quine is run. [Answer] ## [Alice](https://github.com/m-ender/alice), 29 bytes ``` 4P.a+80pa2&wdt,kd&w74,.ok@ ``` [Try it online!](https://tio.run/##S8zJTE79/98kQC9R28KgQCLRSEutPKVEJztFrdzcREtHLz/b4f9/AA "Alice – Try It Online") The unprintable character is 0x18. ### Explanation The trouble with the usual `"`-based Fungeoid quines is that if we repeat the entire source code, then we also get additional `"` and the string no longer covers the entire source code. I assume that's why the existing answer uses the cheat-y `g` approach instead. This answer does use the `"`-based approach, but instead of including a `"` in the source, we write it into the program at runtime. That way, there will only ever be one `"` regardless of how often the program is repeated (because we only write it to one specific coordinate, independently of program size). The general idea is then that we create a representation of the whole source code on the stack, but only cycle through the first 29 of the characters (i.e. the program length) with the length of the loop determined by the size of the code. Therefore, we can actually append arbitrary characters (except linefeeds) after `@` and the result will always be a cyclic repetition of the core program, one character longer than the source. ``` 4P Push 4! = 24. This is the code point of the unprintable, which we're using as a placeholder for the quote. .a+ Duplicate it and add 10, to get 34 = '"'. 80p Write '"' to cell (8,0), i.e. where the first unprintable is. Placeholder, becomes " by the time we get here, and pushes the code points of the entire program to the stack. However, since we're already a good bit into the program, the order will be messed up: the bottom of the stack starts at the 24 (the unprintable) followed by all characters after it (including those from extraneous repetitions). Then on top we have the characters that come in front of the `"`. So if the initial program has structure AB, then any valid program has the form ABC (where C is a cyclic repetition of the initial program), and the stack ends up holding BCA. We don't care about C, except to determine how big the program is. So the first thing we need to do is bring B to the top, so that we've got the initial program on top of the stack: a2* Push 102 = 20. &w Run the following section 21 times, which is the length of B. dt, Pull up the value at the bottom of the stack. k End of loop. d&w Run the following section D+1 times, where D is the length of ABC. 74 Push 28, one less than the number of characters in AB. , Pull up the 29th stack element, which is the next character to print. .o Print a copy of that character. k End of loop. @ Terminate the program. ``` [Answer] # [Perl 5](https://www.perl.org/), 83 bytes (including final newline) ``` $_=q($/=$;;$_="\$_=q($_);eval __END__ ".<DATA>;print$_,/(.).{82}\z/s);eval __END__ ``` [Try it online!](https://tio.run/nexus/perl5#@68Sb1uooaJvq2JtDWQqxUD48ZrWqWWJOVzx8a5@LvHxXEp6Ni6OIY521gVFmXklKvE6@hp6mnrVFka1MVX6xaiK//8HAA "Perl 5 – TIO Nexus") The good ol' [`__DATA__` token](http://perldoc.perl.org/perldata.html#Special-Literals) makes it easy to append an arbitrary string to any Perl program, which the main program can then access via the `<DATA>` file handle (and actually using `__END__`, which does the same thing for backwards compatibility, instead of `__DATA__` saves two extra bytes). Note that this program does not read its own source code, but only the extra input data appended to its source after the `__END__` token. In effect, the `__END__` token and everything after it functions kind of like a string literal terminated by the end of the input. Also note that, in order to meet the spec exactly, this program must end in a newline. If it does not, the newline actually gets automatically appended after the second `__END__` anyway, but then the first iteration output won't be precisely equal to the code plus its first byte any more. [Answer] # [Befunge-98](https://github.com/catseye/FBBI), 30 bytes ``` 0>:#;0g:840#;+#1-#,_$a3%0g,@ ``` [Try it online!](https://tio.run/nexus/befunge-98#@29gZ6VsbZBuZWFioGytraVsqKusE6@SaKylapCu4/D/PwA "Befunge-98 – TIO Nexus") My try using Befunge-98 which uses a space terminated quine which also counts how many characters have been outputed. Does however use the `g` command. [Answer] # PHP, 146 bytes ``` ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?> ``` It should be run using `-r` in command line. [Answer] # [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 61 bytes ``` 803X4+kw.'.q}͍}͍}͍}͍}͍}͍}͍}͍}͍::l͍5X-:}-$:l͍{-1--@ ``` [Try it online!](https://tio.run/##KyrNy0z@/9/CwDjCRDu7XE9dr7D2bC8uZGWVc7bXNELXqlZXBcSs1jXU1XX4/x8A "Runic Enchantments – Try It Online") Uses a similar approach as the Alice answer: reflectively writes the string `"` command into the code so that there Is Only One. There rest is a lot of string and stack manipulation to recover the original program, how many extra bytes are needed, and print the necessary hunks. The `}͍` sequence rotates the in-memory string representation around so that the `803X4+kw` appears at the beginning instead of at the end, due to the position of the `"` and there isn't an easier way of handling this operation without having to compute a lot of awkward numbers. While the original program is 61 bytes its string-length is only 50, which is easy to construct as `5X` and it was only coincidence that this didn't need to be padded out after containing all necessary functionality (e.g. a length 49 program would be easier to encode as `50` with one byte of padding than to encode a literal `49`, while `51` would be encoded as `5X3+` or 53, having to account for its own extra bytes). ]
[Question] [ Inspired by [this](https://chat.stackexchange.com/transcript/message/49893872#49893872) chat mini-challenge. Given a string as input (ASCII printable characters only), output the string with the letters "raining" down. Each letter must be a random number of lines downward (random between `0` and the length of the string, each having non-zero probability), and only one character per column. All possible outputs must again have a non-zero probability of occurring. That's maybe a little confusing, so here's an example (taken from that CMC): ``` Hello World d H o llo l W e r ``` Note how the `H` is one space down, the `d` is zero down, and the `llo` all happen to line up. The `r` is the farthest down, at `9`, but is still less than the string length away from the top. This is just one example, there are dozens of other possibilities for input `Hello World`. Other examples could be: ``` test t e s t PP&CG & G P P C ``` --- * Input and output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963). * The input is guaranteed non-empty (i.e., you'll never receive `""` as input). * You can print it to STDOUT or return it as a function result. * Either a full program or a function are acceptable. * Any amount of extraneous whitespace is acceptable, so long as the characters line up appropriately (e.g., feel free to pad as a rectangle). * [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden. * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins. [Answer] # [R](https://www.r-project.org/), 104 bytes ``` function(s){m=matrix(" ",l<-nchar(s),l) m[cbind(1:l,sample(l,l,T))]=el(strsplit(s,"")) write(m,1,l,,"")} ``` [Try it online!](https://tio.run/##FcqxCsIwEIDhvU8RbpA7uA5dpZ0cXDu4SYcYEwzcxZJELIjPHuv6f39uwYy9aeGVXI3PhIU@OqmtOW4IBljGPrmHzTuwUKdXd4vpjsNRuFhdxaOw8IVombxgqbmsEisWBiDq3jlWj8rD/vzLtwWEeT4dzkDtBw "R – Try It Online") Input as a string; writes to stdout. [Answer] # JavaScript (ES6), 72 bytes Takes input as a list of characters. Returns a matrix of characters. ``` a=>a.map((_,y)=>a.map((c,x)=>Math.random()<.5\|!a[y+1]?(a[x]=' ',c):' ')) ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i5RLzexQEMjXqdSE85J1qkAcnwTSzL0ihLzUvJzNTRt9ExrFBOjK7UNY@01EqMrYm3VFdR1kjWtgJSm5v/k/Lzi/JxUvZz8dI00jWg9PT11j9ScnHyF8PyinBT1WE1NLixKSlKLS3DJBQSoObuDJP8DAA "JavaScript (Node.js) – Try It Online") [Answer] # Pyth - 9 bytes Outputs list of lines. ``` .tm+;OlQ .t Transpose, padding with spaces m (Q implicit) Map over input + (d implicit) Concatenate to loop var String repeat ; This refers to the var replaced by loop var, which is d=" " O Random number less than lQ Length of input ``` [Try it online](http://pyth.herokuapp.com/?code=.tm%2B%2a%3BOlQ&test_suite=1&test_suite_input=%22Hello+World%22%0A%22PP%26CG%22%0A%22test%22&debug=0). [Answer] # [J](http://jsoftware.com/), ~~30~~ 19 bytes ``` \|:@,.]{.~"+_2-#?@## ``` [Try it online!](https://tio.run/##y/qvpKegnqZga6WgrqCjYKBgBcS6egrOQT5u/2usHHT0Yqv16pS04410le0dlJX/a3JZKloZKtjoaeubKVoZKKirc5Ukg7WXpBaXqFure6Tm5OQrhOcX5aQAeQEBas7u6lwaqckZ@Q4axgYq6rrqmkrx1mB@GoRS17VThwppqunZKZQk/wcA "J – Try It Online") [Answer] # [Japt](https://github.com/ETHproductions/japt), 8 bytes -1 byte from @Shaggy ``` y_iUÊö ç ``` --- ``` y_iUÊö ç Full Program. Implicit input U y_ transpose and map each row in U (Call it X) i Insert at the beginning of X: ç " " repeated ↓ many times UÊö random integer in [0, length of U] implicit transpose back and output ``` [Try it online!](https://tio.run/##y0osKPn/vzI@M/Rw1@FtCoeX//@v5JGak5OvEJ5flJOiBAA "Japt – Try It Online") [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 16 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set") Anonymous tacit prefix function ``` ⍉∘↑⊢↑¨⍨∘-∘?≢⍴1+≢ ``` `≢` length of string `1+` one added to that `≢⍴` "length" copies of that `∘?` random integers in range 1…those, and then… `∘-` negate, and then… `⊢↑¨⍨` take than many elements from each character, padding on the left with spaces `∘↑` mix list of strings into matrix, padding with spaces on the right `⍉` transpose [Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Fv56OOGY/aJj7qWgQkD6141LsCKKALxPaPOhc96t1iqA2k/6c9apvwqLfvUd9UT/9HXc2H1huD9PRNDQ5yBpIhHp7B/9PUFTxSc3LyFcLzi3JS1Ll0dXW50hTUS1KLS@CcgAA1Z3d1AA "APL (Dyalog Unicode) – Try It Online") [Answer] # Julia, 69 bytes ``` f(s)=(n=length(s);z=fill(' ',n,n);for i=1:n z[rand(1:n),i]=s[i]end;z) ``` This defines a function `f` that accepts a `String` or `Vector{Char}` and returns a `Matrix{Char}`. Ungolfed: ``` function f(s) n = length(s) z = fill(' ', n, n) # an n×n matrix of spaces for i = 1:n # set a random entry in the ith column to the ith character in s z[rand(1:n),i] = s[i] end z end ``` Example: ``` julia> f("test") 4×4 Array{Char,2}: 't' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'e' ' ' 't' ' ' ' ' 's' ' ' ``` This could surely be better; my golfing skills are pretty rusty. [Try it online!](https://tio.run/##TU4xCsMwDNzzCpGhscFL1gRPHdoxW4fgIRC7VRBysVMw/nzqJBQqENLp7jgtH8KpTdvmRJRasCbLz/VVQJ@1QyLRQKNYseydD4C67RjyGCaeRVmlQqPjiMby3Ge57ZoIGsb6bok8PHyguVZQrzau@xyGy/VWmwpKvQPySlyyDpiKz/3AEVYObRcxW5EUtCfxb1w8skgjqs7Iky1vVKW3Lw "Julia 1.0 – Try It Online") [Answer] # [Japt](https://github.com/ETHproductions/japt), 8 bytes ``` yÈùUÊö Ä ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=ecj5Vcr2IMQ&input=IkhlbGxvIFdvcmxkIg) ``` yÈùUÊö Ä :Implicit input of string U y :Transpose È :Pass each column through the following function and transpose back ù : Left pad with spaces to length UÊ : Length of U ö : Random number in the range [0,UÊ) Ä : Plus 1 ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes ``` ³LŻX⁶x;)z⁶ ``` [Try it online!](https://tio.run/##y0rNyan8///QZp@juyMeNW6rsNasAlL/D7dH/v/vAZTMVwjPL8pJUQQA "Jelly – Try It Online") ``` ) \| For each input character ³L \| Length of original input Ż \| 0..length X \| Random number from that list ⁶x \| That number of spaces ; \| Concatenate to the character z⁶ \| Finally transpose with space as filler ``` [Answer] # [Ruby](https://www.ruby-lang.org/), ~~59~~ ~~57~~ 55 bytes ``` ->a{a.map{\|c\|s=[' ']z=a.size;s[rand z]=c;s}.transpose} ``` [Try it online!](https://tio.run/##Fcw9DkAwGADQqzQGf4kegNTsBoamw6cqSGnTrwbF2YvxLc8dwxknFqsWLqAb2OuWNzKekUyUgQHFJagGuYN9JEEw2eBD/Se0BtUT7eGRTDzplNaG9MbpMaFyBofi3/K0Xs2yF/EF "Ruby – Try It Online") Inputs 1D, outputs 2D array of characters. [Answer] # [PHP](https://php.net/), 88 bytes ``` for($o='';$i<$l=strlen($argn);$o[$i+$lrand(0,$l)]=$argn[$i++]);echo chunk_split($o,$l); ``` [Try it online!](https://tio.run/##TY49C8IwEIb3/IobDpNqheKaFgcRHQS7OUgpoY2mGJqQxEn87TW1im539348Z5Ud8rVVlhAM0gcPBZwJAN1LrQ2cjNMtTcfDqE5TWc42O0oqTsjFOCkaxT5Z4QGFu/YJPKJRNspMewrlvqy3xwMfYoKhKSjl2OWoCx@clj2bYhzNGbsF6rkTfcuyFHVSFW9tvC@qhL9LG3Xvb7W3uguxbHTxAQC7@HzGv@QP8sf@ChFZO2mlCIwuabrKkj/Pc3gB "PHP – Try It Online") Or 94 bytes using PHP's [cryptographic random integers](https://www.php.net/manual/en/function.random-int.php) function. ``` for($o='';$i<$l=strlen($argn);$o[$i+$lrandom_int(0,$l)]=$argn[$i++]);echo chunk_split($o,$l); ``` [Try it online!](https://tio.run/##TY8xb8IwEIV3/4obTtghqRSxmqgDQjAgNRsDiiIrmNrC2JbtTlV/e@oQEGx39753784rP64/vfKEYJIxRWjgRADoXhrj4OiCOdNqGkzqXLXtYrOjpOOEXFyQYlDs4RURUIRvW8BvBuWg3NxX0O7bfvt14GN2MHQNpRz1Gk0TUzDSstnG0Z1Ql2iWQdizu/XaJlZXaIquuROTWnYFv68e1I@99tEbnfLKieIjAOr8Qs2f@Y/g1wVPIQf3QXopEqMftFrVxRvzN/4D "PHP – Try It Online") Input from `STDIN`, output to `STDOUT`. Run as: ``` $ echo Hello World\|php -nF rain.php l W l e r d H o l o ``` -1 byte (empty string instead of space) and +1 byte (err on side of rules) thx to @ASCII-only! [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal), ~~10~~ 9 bytes ``` ↑Ｅθ◧ι⊕‽Ｌθ ``` [Try it online!](https://tio.run/##HcFRCoAgDADQ/07h5wK7QF2gwCCC6HvoSmHNEun6C3rPRyw@I6suJUmFfrutmfGGx5oFg6OjQrJmEl/oIqkUYEUJ@QJHctYIT/sbVEdizmbPhUOj3csf "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved 1 byte thanks to @ASCII-only. Explanation: ``` θ Input string Ｅ Map over characters θ Input string Ｌ Length ‽ Random value ⊕ Incremented ι Current character ◧ Padded to length ↑ Print rotated ``` As ASCII-only points out, you can move the letters randomly up instead of down for the same effect (except that there might be extra white space at the bottom rather than the top). Printing an array of characters upwards is equivalent to printing a string normally, so the padding then just offsets each character vertically by a random amount. [Answer] # [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` εIgÝΩú}ζ» ``` Input as a string or list of characters (either is fine). [Try it online.](https://tio.run/##ASQA2/8wNWFiMWX//861SWfDnc6pw7p9zrbCu///SGVsbG8gV29ybGQ) Much slower 9-bytes alternative:* ``` gDÝsãΩúζ» ``` Input as a list of characters. [Try it online.](https://tio.run/##MzBNTDJM/f8/3eXw3OLDi8@tPLzr3LZDu///j1byUNJRSgXiHCjOV4oFAA) Both use the legacy version of 05AB1E, since the new version requires an explicit `€S` before the `ζ`.. Explanation: ``` ε # Map each character in the (implicit) input to: Ig # Take the length of the input Ý # Create a list in the range [0, input-length] Ω # Pop and push a random integer from this list ú # Pad the current character with that many leading spaces }ζ # After the map: zip/transpose; swapping rows/columns (with space as default filler) » # Then join all strings by newlines (and it output implicitly as result) g # Get the length of the (implicit) input-list D # Duplicate this length Ý # Create a list in the range [0, input-length] sã # Take the cartesian product of this list that many times Ω # Pop and push a random list from this list of lists of integers ú # Pad the characters in the (implicit) input-list with that many spaces ζ # Zip/transpose; swapping rows/columns (with space as default filler) » # Then join all strings by newlines (and it output implicitly as result) ``` [Answer] # [Perl 5](https://www.perl.org/) `-F`, ~~50~~ 49 bytes -1 by @DomHastings ``` map$;[rand@F][$i++]=$_,@F;say map$_\|\|' ',@$_ for@ ``` [Try it online!](https://tio.run/##K0gtyjH9/z83sUDFOrooMS/FwS02WiVTWzvWViVex8HNujixUgEkG19To66gruOgEq@Qll/k8P@/R2pOTr5CeH5RTsq//IKSzPy84v@6vqZ6BoYG/3XdAA "Perl 5 – Try It Online") [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~108~~ ~~102~~ 98 bytes -4 bytes thanks to mazzy ``` $a=1..($z=($y=$args\|% ty).count)\|%{random $z} 1..$z\|%{-join($y\|%{" $_"[$a[$i++%$z]-eq+$r]});$r++} ``` [Try it online!](https://tio.run/##DYvdCoMgAEbvfQqRr8hJQvuH4ZNEDNlqNVpu1hhZPrvz7nA4521@tR3buu8DGrUEaFVImcGpDLOCto9xTei0mbm8me8w8TVZrB7u5kXhPIktXFT503RDPCIyiisroUt0QiRwVV5/BGzl@QVWCB88ISkayortbp8ejqczC38 "PowerShell – Try It Online") Basically iterates `1..length` of the string twice, once to get random line locations for each character, and a second time to actually build each line using those indices. Figuring out how to do it in one sweep is where the big byte savings are. [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~131~~ 125 bytes -6 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat) ``` f(chars){int l=strlen(s),R[l],i=l,j;for(srand(&l);i--;)R[i]=rand()%l;for(;++i<ll;printf("\n%c"+!!j,i/l^R[j=i%l]?32:s[j]));} ``` [Try it online!](https://tio.run/##dY2xDoIwGIRneQoggfQHGhPdrMTBQUfC4oCYkAJa8ltIWyfCs1dg1vHuvrvj9Mm5tS3hr0pFGkYhjYupNgobSTQkeYFlIlJMOtb2imhVyZqECExQyiAvRJmuFgS4AiyOxREjZIOap1ri32XA/djzukRs8ZEXXSoCLE/73UEXXQnAJrt8vishCTijs5k71waxd2@9wtoH5g4fo5chSuksV8I02vyJsiw8X35kk/0C "C (gcc) – Try It Online") [Answer] # AWK, ~~120~~ 118 bytes ``` {while(i++<NF)r[i]=int(rand()NF)+1;for(;l++<NF;j=k=0){while(k++<NF)if(r[k]==l){printf"%c",k-j,$k;j=k}print FS}} ``` [Try it online!](https://tio.run/##SyzP/v/fydXd06/aLdhWSam2ujwjMydVI1Nb28bPTbMoOjPWNjOvRKMoMS9FQ1MLKKRtaJ2WX6RhnQNWYZ1lm21roAnVlQ3RlZmmURSdHWtrm6NZXVAE1J6mpKqVrKSTrZulo5IN0lILFlZwC66t/f/fIzUnJ18hPL8oJ@U/AA "AWK – Try It Online") I've included the 5 bytes in the score for the necessary `-F ''` switch, but I had to use the `BEGIN{FS=""}` directive for the TIO link since it doesn't process the command-line switch properly. [Answer] # SmileBASIC 3, 62 bytes ``` LINPUT T$L=LEN(T$)CLS FOR I=0TO L-1LOCATE,RND(L+1)?T$[I]; NEXT ``` [Answer] # [Red](http://www.red-lang.org), 84 bytes ``` func[s][foreach n random collect[repeat n length? s[keep n]][print pad/left s/:n n]] ``` [Try it online!](https://tio.run/##XcqxDsIgFEbhnae4MrgZ9i4ODjo2roSBwI81Xi8EMH18rOnmGU@@ijjuiNap6iXmt2lAJMmrShON9JFgm7MpV/iwkNCuKGRmhG4rCnzfPkMefTlTsy@gkDhnS31Kp@KjYaROzUzy@yORvoE505orx4NWO9Snv7Ta5DwfL1c9vg "Red – Try It Online") [Answer] # Python - 92 bytes ``` import random lambda s:map(None,[(random.randrange(len(s))' '+c).ljust(len(s))for c in s]) ``` [Answer] # [K (oK)](https://github.com/JohnEarnest/ok), 20 bytes Solution:* ``` +c$(-1-c?c:#x)$++x: ``` [Try it online!](https://tio.run/##y9bNz/7/XztZRUPXUDfZPtlKuUJTRVu7wkrJIzUnJ18hPL8oJ0WJ6/9/AA "K (oK) – Try It Online") Explanation: ``` +c$(-1-c?c:#x)$++x: / the solution x: / store input as x + / flip (enlist) + / flip again (break into chars) $ / pad (each) character ( ) / do this together #x / length of x c: / save as c -c? / choose (?) c times from c -1 / subtract from -1 c$ / pad to length of x + / flip ``` [Answer] # [Python 3](https://docs.python.org/3/), ~~140~~ 131 bytes ``` from random import* def f(s): e=range(len(s)) p=[choice(e)for t in s] for r in e:print(''.join((r-p[i]and' 'or s[i]for i in e))) ``` [Try it online!](https://tio.run/##VY3BCsIwEETPzVcsuSQr6MVboV9Se5B2YyPpbtgGxK@PqZ48DW/mweR3WYWvtQaVDfTOS4u4ZdFyMgsFCH7H3nQ0tO1BPhG3Ak2Xh3FeJc7kCYMoFIgM@2S6A/QA6rNGLt65y1Mie6/nPMapXThwTdobHHL8yohYf75dKSWBl2habmzRhL/KYv0A "Python 3 – Try It Online") [Answer] # Python 3, 208 bytes ``` import random as r;x=input();R=range(len(x));c=[r.choice(R) for i in R];y=[' 'c[i]+x[i]+' '(len(x)-c[i]) for i in R];R=range(len(y));print('\n'.join([''.join(r) for r in [[y[i][j] for i in R] for j in R]])) ``` Creates a list of random choices, then makes a list of columns with blank space everywhere except at the index specified by each random choice. The columns are transposed into rows and printed out with newlines between them. [Try it online!](https://tio.run/##VYxBDsIgEEWvMq4Ajd24JFyiW2TRYLXT2IFMMSmnx2K7qJvJm5//X8xpCHQrBacYOAF39AgTdDOwXgxS/CSpdGvW/NXLd09yUUp7Y7nxQ0Dfy1bBMzAgIEHrdDZWgDh7i@6y1FO/fXit6X/9aM6rOTJSkuJOohkDkrRiB952XHfW5lVkR3dU/Xjc2ClVCndI@fQF) ]
[Question] [ # A Fragile Quine A fragile quine is a quine that satisfies the property of having each substring made by removing a single character, when evaluated, produces an error. For example. If your program `asdf` is a quine, then for it to be fragile, the following programs must error: ``` sdf adf asf asd ``` Your program (and all of its substrings) must be fully deterministic, and must be in the same language. A program falling into an infinite loop (that is, failing to terminate), even if not eventually producing an error is considered to "produce an error" for the purposes of this challenge. Standard loopholes apply, including the usual quine restrictions (e.g. not able to read own source code). For example, `print("foo")` is not fragile. All these substrings must error: ``` rint("foo") pint("foo") prnt("foo") prit("foo") prin("foo") print"foo") print(foo") print("oo") print("fo") print("fo") print("foo) print("foo" ``` The ones that don't error are: ``` print("oo") print("fo") print("fo") ``` So it is not fragile. ## An important note on quines [By consensus](https://codegolf.meta.stackexchange.com/questions/4877/what-counts-as-a-proper-quine/4878#4878), any possible quine must satisfy this: > > > > > > It must be possible to identify a section of the program which encodes a different part of the program. ("Different" meaning that the two parts appear in different positions.) > > > > > > Furthermore, a quine must not access its own source, directly or indirectly. > > > > > > > > > ## Example Since I consider JavaScript's function#toString to be "reading it's own source code", I am disallowing it. However, if I weren't to bar it, here is a fragile quine in JavaScript: ``` f=(n=b=`f=${f}`)=>(a=(n)==`f=${f}`,n=0,a)&(n!=b)?b:q ``` ## Tester Here is a program that, given the source code of your program, generates all programs that must error. ``` let f = (s) => [...Array(s.length).keys()].map(i => s.slice(0, i) + s.slice(i + 1)).join("\n"); let update = () => { output.innerHTML = ""; output.appendChild(document.createTextNode(f(input.value))); }; input.addEventListener("change", update); update(); ``` ``` #output { white-space: pre; } #input, #output { font-family: Consolas, monospace; } ``` ``` <input id="input" value="print('foo')"> <div id="output"></div> ``` [Answer] # Python 3, 45 bytes ``` c='print(end="c=%r;exec(c"%c+c[84])';exec(c) ``` Switching to Python 3 so that the trailing newline can be easily removed. I started out with a stupid structure that had 2 variables instead of 1, but switching to 1 variable only made it 4 bytes shorter. -(4 + 3) bytes by Dennis. [Answer] # Python, ~~91/92~~ 67 bytes This was fun! Now I know about assert: ``` s='s=%r;assert len(s)==34;print(s%%s)';assert len(s)==34;print(s%s) ``` If a char from string is removed, assert error. I would have done this sooner had I known of this feature, assert. [Answer] # Python 2, ~~51~~ ~~50~~ 46 bytes ``` lambda s='lambda s=%r:s[22:]%%s%%s':s[22:]%s%s ``` Verify it on [Ideone](http://ideone.com/Q2M2xp). [Answer] ## [Burlesque](https://esolangs.org/wiki/Burlesque), ~~32~~ ~~28~~ 25 bytes ``` {3SHWD{Je!}.+{Sh}\msh}Je! ``` [Try it here.](http://64.137.252.151/%7Eburlesque/burlesque.cgi?q=%7B3SHWD%7BJe%21%7D.%2B%7BSh%7D%5Cmsh%7DJe%21) So most instructions in Burlesque are 2 characters. And it is much easier to write a quine in Burlesque than in Marbelous. `Je!` or `^^e!` means `_~` in CJam. [Answer] # C#, 145 bytes ``` _=>{var@s="_=>{{var@s={1}{0}{1};for(;79!=s.Length;){{}}System.Console.Write(s,s,'{1}');}};";for(;79!=s.Length;){}System.Console.Write(s,s,'"');}; ``` I've not written a quine in C# before, but higher scores are better in golf, right? :) Infinite loop if a char is removed from the string or a digit from the magic const 79. Removing any other char results in a compile error. Ungolfed: ``` / Action<object> Quine = */ _ => // unused parameter { // String of the function (well, mostly). // {0} placeholder for s, so the output contains the function and string. // {1} placeholder for " since it requires escaping. var@s = "_=>{{var@s={1}{0}{1};for(;79!=s.Length;){{}}System.Console.Write(s,s,'{1}');}};"; // Infinite loop if a char is removed from the above string or if the 7 or 9 is removed. for(;79!=s.Length;){} // Print the quine. System.Console.Write(s,s,'"'); }; ``` [Answer] # JavaScript, 90 bytes ``` a="a=%s;a[44]!=')'?x:console.log(a,uneval(''+a))";a[44]!=')'?x:console.log(a,uneval(''+a)) ``` Works in the console of Firefox 48, and should work in any other environment with `uneval` and `console.log`. Breakdown of errors: ``` a=" "; [ ]!=' '?x: (a (''+a)) // SyntaxError a=%s;a[44]!=')'?x:console.log(a,uneval(''+a)) a 44 ) // ReferenceError from calling `x` console. ,uneval // ReferenceError from calling `onsole.log`, `auneval`, etc. log // TypeError from calling `console.og`, etc. ``` [Answer] # Python 2, 59 bytes ``` x='x=%r;1/(len(x)==30);print x%%x';1/(len(x)==30);print x%x ``` This throws a `ZeroDivisionError` if a 0, a 3, or a character is removed from the string. Removing a different character results in a `NameError` or a `SyntaxError`. [Answer] # [A Pear Tree](https://esolangs.org/wiki/A_Pear_Tree), 50 bytes ``` a="print('a='.repr(a).';eval(a)');#f+QF>";eval(a) ``` [Try it online!](https://tio.run/##S9QtSE0s0i0pSk39/z/RVqmgKDOvREM90VZdryi1oEgjUVNP3Tq1LDEHyFLXtFZO0w50s1OCiXD9/w8A "A Pear Tree – Try It Online") Not the shortest answer, but a fairly comprehensive one; any character deletion from this program causes it to fail to checksum, thus the A Pear Tree interpreter won't even attempt to run it. (For example, you get an error if you delete the trailing newline.) The `;#f+QF>` is used to ensure that the program as a whole has a CRC-32 of 0 (and `f+QF>` is one of three possible 5-byte strings that could be placed in the comment to achieve that while staying in ASCII; using ASCII is important here because `repr` would fail to round-trip it correctly otherwise). ]
[Question] [ If you've ever learned about primes in math class, you've probably have had to, at one point, determine if a number is prime. You've probably messed up while you were still learning them, for example, mistaking 39 for a prime. Well, not to worry, as 39 is a semiprime, i.e., that it is the product of two primes. Similarly, we can define a k-almost prime as being the product of k prime numbers. For example, 40 is the 4th 4-almost prime; 40 = 5\2\2\2, the product of 4 factors. Your task is to write a program/function that accepts two integers n* and k as input and output/return the nth k-almost prime number. This is a code-golf, so the shortest program in bytes wins. ## Test cases ``` n, k => output n, 1 => the nth prime number 1, 1 => 2 3, 1 => 5 1, 2 => 4 3, 2 => 9 5, 3 => 27 ``` # Miscellaneous You have to generate the primes yourself by any means other than a simple closed form, if such a closed form exists. [Answer] ## Pyth, 9 bytes ``` e.fqlPZQE ``` Explanation ``` - autoassign Q = eval(input()) PZ - prime_factors(Z) l - len(^) q Q - ^ == Q .f E - first eval(input()) of (^ for Z in range(inf)) e - ^[-1] ``` [Try it here!](http://pyth.herokuapp.com/?code=e.fqlPZQE&input=3%0A5&debug=0) [Or try a test suite!](http://pyth.herokuapp.com/?code=e.fqlPZQE&input=3%0A5&test_suite=1&test_suite_input=1%0A1%0A1%0A3%0A2%0A1%0A2%0A3%0A3%0A5&debug=0&input_size=2) [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 9 bytes Beating @sundar by using half as much bytes ``` {~l~ḋ}ᶠ⁽t ``` # Explanation ``` -- Input like [n,k] { }ᶠ⁽ -- Find the first n values which ~ḋ -- have a prime decomposition ~l -- of length k t -- and take the last one ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r/v7oup@7hju7ah9sWPGrcW/L/f7SpjnHs/ygA "Brachylog – Try It Online") [Answer] # Jelly, 9 bytes ``` ÆfL=³ ç#Ṫ ``` [Try it online!](http://jelly.tryitonline.net/#code=w4ZmTD3CswrDhyPhuao&input=&args=Mw+NQ) ### How it works ``` Ç#Ṫ Main link. Left input: k. Right input: n. Ç Apply the helper link to k, k + 1, k + 2, ... until... # n matches are found. Ṫ Retrieve the last match. ÆfL=³ Helper link. Left argument: k (iterator) Æf Yield the prime factors of k. L Compute the length of the list, i.e., the number of prime factors. =³ Compare the result with k (left input). ``` [Answer] ## [Pyke](https://github.com/muddyfish/PYKE/tree/9e0140f09cee5922e3931615c31216eb387738ce) (commit 29), 8 bytes (noncompetitive) ``` .fPlQq)e ``` Explanation: ``` - autoassign Q = eval_or_not(input()) .f ) - First eval_or_not(input) of (^ for i in range(inf)) P - prime_factors(i) l - len(^) q - ^==V Q - Q e - ^[-1] ``` [Answer] # Julia, ~~84~~ ~~78~~ ~~59~~ 57 bytes ``` f(n,k,i=1)=n>0?f(n-(sum(values(factor(i)))==k),k,i+1):i-1 ``` This is a recursive function that accepts two integers and returns an integer. The approach here is to check the sum of the exponents in the prime factorization against `k`. Ungolfed: ``` function f(n, k, i=1) # We initialize a counter i as a function argument. # Recurse while we've encountered fewer than n k-almost primes if n > 0 # If the sum of the exponents in the prime factorization of i is # equal to k, there are k prime factors of i. We subtract a boolean # from n, which is implicitly cast to an integer, which will # decrement n if i is k-almost prime and leave it as is otherwise. return f(n - (sum(values(factor(i))) == k), k, i + 1) else # Otherwise we return i-1 (i will have been incremented one too # many times, hence the -1) return i - 1 end end ``` [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 8 bytes ``` λǐL⁰=;ȯt ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLOu8eQTOKBsD07yK90IiwiIiwiNVxuMyJd) ``` λ ;ȯt # Nth number where ǐL # Prime factor length ⁰= # Equal to input ``` [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 18 bytes ``` ,1{hH&t<NḋlH;N}ⁱ⁽t ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r/X8ewOsNDrcTG7@GO7hwPa7/aR40bHzXuLfn/P9pUR8E49n8UAA "Brachylog – Try It Online") ``` Implicit input, say [5, 3] ,1 Append 1 to the input list. [5, 3, 1] { }ⁱ⁽ Repeat this predicate the number of times given by the first element of the list (5), on the rest of the list [3, 1] hH& Let's call the first element H t<N There is a number N greater than the second element ḋ Whose prime factorization's l length H is equal to H ;N Then, pair that N with H and let that be input for the next iteration t At the end of iterations, take the last N This is implicitly the output ``` [Answer] # [Sidef](https://github.com/trizen/sidef), 21 bytes ``` nth_almost_prime(n,k) ``` [Answer] # Mathematica, ~~56~~ 51 bytes ``` Last@Select[Range[2^##],PrimeOmega@#==n&/.n->#2,#]& ``` Warning: This is theoretical. Do not run for any values>4. Replace 2^## with a more efficient expression. [Answer] # Mathematica, ~~53~~ 49 Bytes ``` Cases[Range[2^(#2+#)],x_/;PrimeOmega@x==#2][[#]]& ``` Generates a list of integers based on a loose upper bound. `PrimeOmega` counts the prime factors with multiplicities, the k-almost prime `Cases` are taken from the list, and the nth member of that subset is returned. [Answer] # Haskell, 88 bytes Can probably be golfed a lot more, as I'm still a newbie to Haskell. The function `q` returns the number of factors of its argument, and `f` uses that to get take the `nth` element of a list made from all numbers that have `k` factors. ``` q n\|n<2=0\|1>0=1+q(div n ([x\|x<-[2..],mod n x<1]!!0)) f n k=filter(\m->q m==k)[1..]!!n-1 ``` [Answer] # MATL, 14 bytes ``` :YqiZ^!XpSu1G) ``` [Try it on MATL Online](https://matl.io/?code=%3AYqiZ%5E%21XpSu1G%29&inputs=5%0A3&version=20.9.2) ``` : % Take first input n implicitly, make range 1 to n Yq % Get corresponding prime numbers (1st prime to nth prime) i % Take the second input k Z^ % Take the k-th cartesian power of the primes list % (Getting all combinations of k primes) !Xp % Multiply each combination (222, 223, 225, ...) Su % Sort and unique 1G) % Take the n-th element of the result ``` [Answer] # Python 3, 100 bytes This is a very simple brute force function. It checks every number starting from 2 with `sympy`'s `factorint` function until it has found `n` `k`-almost primes, at which point, the function returns the `n`th of these. ``` import sympy def a(n,k): z=1;c=0 while c<n:z+=1;c+=(sum(sympy.factorint(z).values())==k) return z ``` Ungolfed: I use `sum(factorint(a).values())` because `factorint` returns a dictionary of `factor: exponent` pairs. Grabbing the values of the dictionary (the exponents) and summing them tells me how many prime factors there are and thus what `k` this `k`-almost prime is. ``` from sympy import factorint def almost(n, k): z = 1 count = 0 while count < n: z += 1 if sum(factorint(a).values()) == k: count += 1 return z ``` [Answer] # [Python 2](https://docs.python.org/2/), 76 bytes ``` f=lambda n,k,p=2,c=0:c==k if p>n else f(n,k,p+1,c)if n%p else f(n/p,k,p,c+1) ``` [Try it online!](https://tio.run/##TY0xDgIhEEVrOcU0JpCdRNhYbYIXMRaIjBLW2Qlu4@lxsTC2772fL@/1sfDYGvk5PK@3AIwFxY8YvZ2i9wUygZwY0vxKQPqrB4fRbJz38uMH6Qbj4EyjpcI2ZKiB70k7PJpJ7aRmXqHgOUMP8l9grek/pDMWc1GqfQA "Python 2 – Try It Online") ]
[Question] [ Given an input string consisting of only letters, return the step-size that results in the minimum amount of steps that are needed to visit all the letters in order over a wrapping alphabet, starting at any letter. For example, take the word, `dog`. If we use a step-size of 1, we end up with: ``` defghijklmnopqrstuvwxyzabcdefg Alphabet ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ defghijklmnopqrstuvwxyzabcdefg Visited letters d o g Needed letters ``` For a total of 30 steps. However, if we use a step-size of 11, we get: ``` defghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefg ^ ^ ^ ^ ^ ^ d o z k v g Visited letters d o g Needed letters ``` For a total of 6 steps. This is the minimum amount of steps, so the return result for `dog` is the step-size; `11`. Test cases: ``` "dog" -> 11 "age" -> 6 "apple" -> 19 "alphabet" -> 9 "aaaaaaa" -> 0 for 0 indexed, 26 for 1 indexed "abcdefga" -> 1 or 9 "aba" -> Any odd number except for 13 "ppcg" -> 15 "codegolf" -> 15 "testcase" -> 9 "z" -> Any number "joking" -> 19 ``` ### Rules * Input will be a non-empty string or array of characters consisting only of the letters `a` to `z` (you can choose between uppercase or lowercase) * Output can be 0 indexed (i.e. the range `0-25`) or 1 indexed (`1-26`) * If there's a tie, you can output any step-size or all of them * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the lowest amount of bytes for each language wins! [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal), 41 bytes ``` ≔ＥＥβＥθ∧μ⌕⭆β§β⁺⌕β§θ⊖μ×κξλ⎇⊕⌊ιΣι⌊ιθＩ⌕θ⌊Φθ⊕ι ``` [Try it online!](https://tio.run/##TU5RCoMwDP3fKfrZQncCv2RD8EMQ3AU6zVxYG2dbhzt919aBBkLyXt5L0j@V7SelQyidw5F4o94575KlMktW0sCNZBXG2nmLNP7npa9pgDW1rV4cz4oDH71X6C0YIA9xhxBCshsacPwl2Zqh3kiwpOyX17TLGyQ0i@GYBF1u4ks7GdEsilMbH/L8opzf7s@7qELtwSbmuDdZYxQh9NMA46Qf4fzRPw "Charcoal – Try It Online") Link is to verbose version of code. 0-indexed. Explanation: ``` Ｅβ ``` Loop over the 26 step sizes. (Actually I loop over the lowercase alphabet here and use the index variable.) ``` Ｅθ∧μ ``` Loop over each character of the input after the first. ``` ⭆β§β⁺⌕β§θ⊖μ×κξ ``` Loop 26 times and generate the string of characters resulting by taking 26 steps at the given step size starting (0-indexed) with the previous character of the input. ``` ⌕...λ ``` Find the position of the current character of the input in that string, or -1 if not found. ``` Ｅ...⎇⊕⌊ιΣι⌊ι ``` Take the sum of all the positions, unless one was not found, in which case use -1. ``` ≔...θ ``` Save the sums. ``` ⌊Φθ⊕ι ``` Find the minimum non-negative sum. ``` Ｉ⌕θ... ``` Find the first step size with that sum and output it. [Answer] # JavaScript, 143 bytes ``` w=>(a=[...Array(26).keys(m=1/0)]).map(s=>~[...w].map(c=>(t+=a.find(v=>!p\|(u(c,36)+~vs-u(p,36))%26==0),p=c),p=t=0,u=parseInt)+t<m&&(m=t,n=s))\|n ``` [Try it online!](https://tio.run/##XZBBboMwEEX3nIJGamIX45JUYpMOUhdd9AwRC8cYSgK2hQeiVFGuTiGt1LizsPSebM/MP4hBONnVFmNtCjWWMJ4gIwJ2nPO3rhNnskkpP6qzIy2snxOaU94KSxxk1/nOKb@hnB5hBIKXtS7IANmDvZCeSPaS0ug6PLm4J3YG@rhJARLKLMj5QEhYD1Z0Tn1opBG@tsvl1AqZBkfpRY@oHLoQwl0Q/taiMNWC/aGolIfWNr5o7KfYK/TcT3lqLwtVVv@ch9ZKr7OcMqtMU967eV4pnDfB1z0czLHW8zf5Nghu290ixBCyUBrtTKN4YyqC3IrifYpzPcW1irMVKwlSSrfjNw "JavaScript (Node.js) – Try It Online") Thanks to Shaggy, using `[...Array(26).keys()]` saves 9 bytes. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~28~~ ~~26~~ 23 bytes ``` S;þḅ26ŒpṢƑƇIŻ€S:g/ƊÞḢg/ ``` Output is 0-indexed. Input is a bytestring and can be in any case, but uppercase is much* faster. Single-letter input has to be special-cased and costs 2 bytes. .\_. [Try it online!](https://tio.run/##y0rNyan8/z/e2DLY@vC@hztajcyOTip4uHPRsYnH2j2P7n7UtCbYKl3/WNfheQ93LErX//9wd4/C0T0Kh9sf7tynApRVcP//P0ndxd9dXUchSd3R3RVCOzpCaCcIHaUOAA "Jelly – Try It Online") Note that this is a brute-force approach; inputs with four or more letters will time out on TIO. The test suite prepends `_39` for "efficiency". ### How it works ``` S;þḅ26ŒpṢƑƇIŻ€S:g/ƊÞḢg/ Main link. Argument: b (bytestring) S Take the sum (s) of the code points in b. ;þ Concatenate table; for each k in [1, ..., s] and each c in b, yield [k, c], grouping by c. ḅ26 Unbase 26; map [k, c] to (26k + c). Œp Take the Cartesian product. ṢƑƇ Comb by fixed sort; keep only increasing lists. I Increments; take the forward differences of each list. Ż€ Prepend a 0 to each list. I returns empty lists for single-letter input, so this is required to keep g/ (reduce by GCD) from crashing. Þ Sort the lists by the link to the left. S:g/Ɗ Divide the sum by the GCD. Ḣ Head; extract the first, smallest element. g/ Compute the GCD. ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 17 bytes ``` ƓI% 26×þ%iþÇo!SỤḢ ``` Input is a bytestring on STDIN, output is 1-indexed. [Try it online!](https://tio.run/##y0rNyan8///YZE9VLiOzw9MP71PNPLzvcHu@YvDD3Use7lj039BI4dCiR01rFCL/Jyml5KcrcSUpJaangqmCghwII6cgIzEptQTMhgAwMyk5JTUtHcoGUwUFyWATkvNTUtPzc9JA7JLU4pLkxGKwSVUgIis/OzMvXQkA "Jelly – Try It Online") ### How it works ``` ƓI% Helper link. Argument: m (26 when called) Ɠ Read a line from STDIN and eval it as Python code. I Increments; take all forward differences. % Take the differences modulo m. 26×þ%iþÇoSSỤḢ Main link. No arguments. 26 Set the argument and the return value to 26. ×þ Create the multiplication table of [1, ..., 26] by [1, ..., 26]. % Take all products modulo 26. Ç Call the helper link with argument 26. iþ Find the index of each integer to the right in each list to the left, grouping by the lists. o! Replace zero indices (element not found) with 26!. This works for strings up to 25! = 15511210043330985984000000 chars, which exceeds Python's 9223372036854775807 character limit on x64. S Take the sum of each column. Ụ Sort the indices by their corresponding values. Ḣ Head; extract the first index, which corresponds to the minimal value. ``` [Answer] # [JavaScript (Node.js)](https://nodejs.org), ~~123 121 116~~ 114 bytes ``` s=>(i=26,F=m=>i--?F((g=x=>s[p]?s[k++>>5]?j=1+g(x+i,p+=b[p]==x%26+97):m:0)(b[p=k=0]+7)>m?m:(r=i,j)):r)(b=Buffer(s)) ``` [Try it online!](https://tio.run/##dZFNboMwEIX3PYWFVMmWSRNShShIA2oXuUSUhfFfTQBbmFS0l6ckUCkCxQsv5n3z5nlcsG/meWNcu6qtkL2C3kOKDWzj8AgVpGa1yo4Ya@gg9Sd3zvzpQmma7s5ZARHVuKMmdBTyQQPoXrcxPexJUiUbgocaXGBzpnuSVlmV4AZMWBCSNIMGn1elZIM9IT23tbelfCutxgoHwuoA3Q4haL1GUfQyA5iWj0C80J0r78RkcFgApftiuWyDEVjq4wkmgw1SthluUwvZSRGibXyvRP@VRX/OhVSaTf4RGuDlkJw9vuKj/kFWCFRfq1w2SHZcunYc8z5vdY6PK5r8d3OAD5@pbamCZ0ArfcuZl8828DtGeww3BpuDhb2Y@hbmf9f9Hw "JavaScript (Node.js) – Try It Online") ### Commented NB: When trying to match a letter in the alphabet with a given step \$i\$, we need to advance the pointer at most \$25\$ times. After \$26\$ unsuccessful iterations, at least one letter must have been visited twice. So, the sequence is going to repeat forever and the letter we're looking for is not part of it. This is why we do `s[k++ >> 5]` in the recursive function \$g\$, so that it gives up after \$32 \times L\$ iterations, where \$L\$ is the length of the input string. ``` s => ( // main function taking the string s i = 26, // i = current step, initialized to 26 F = m => // F = recursive function taking the current minimum m i-- ? // decrement i; if i was not equal to 0: F( // do a recursive call to F: (g = x => // g = recursive function taking a character ID x s[p] ? // if there's still at least one letter to match: s[k++ >> 5] ? // if we've done less than 32 * s.length iterations: j = 1 + g( // add 1 to the final result and add the result of x + i, // a recursive call to g with x = x + i p += b[p] == // increment p if x % 26 + 97 // the current letter is matching ) // end of recursive call to g : // else (we've done too many iterations): m // stop recursion and yield the current minimum : // else (all letters have been matched): 0 // stop recursion and yield 0 )( // initial call to g with p = k = 0 b[p = k = 0] + 7 // and x = ID of 1st letter ) > m ? // if the result is not better than the current minimum: m // leave m unchanged : // else: (r = i, j) // update m to j and r to i ) // end of recursive call to F : // else (i = 0): r // stop recursion and return the final result r )(b = Buffer(s)) // initial call to F with m = b = list of ASCII codes of s ``` [Answer] # [Ruby](https://www.ruby-lang.org/), ~~121~~ ~~114~~ ~~112~~ ~~108~~ ~~102~~ 89 bytes ``` ->s{(r=0..25).min_by{\|l\|p,=s;s.sum{\|c\|t=r.find{\|i\|(p.ord-c.ord+il)%26<1}\|\|1/0.0;p=c;t}}} ``` [Try it online!](https://tio.run/##LczNbsIwEATge58islQJ2uAGJHpJzYsgVDnrn7g18co2B/D62VMldA4z32nibbjPRsy7UyqbKDrOD8ctv7rpe7gX8oStSH3i6XYtBJRF5MZNqpCjDfIQ1Q6Wfndvfvt6@PzaV6L9R8e7HgX0udY6n5kKlrVMWs3ahklE/4THUQ46r35m5QBKG/vvdRDBLgtBaRu8WZx1yiDT@vRY6if8usmylwvXEsZCmRpszDlzGGVMlzr/AQ "Ruby – Try It Online") 0-indexed. Takes input as an array of characters. Thanks to ASCII-only for golfing ideas worth 12 bytes. [Answer] # [Python 2](https://docs.python.org/2/), ~~230~~ ~~222~~ ~~216~~ ~~194~~ 169 bytes ``` def t(s,l,S=0): a=ord(s[0]) for c in s[1:]: while a-ord(c)and S<len(s)26:S+=1;a=(a-65+l)%26+65 return S def f(s):T=[t(s,l)for l in range(26)];return T.index(min(T)) ``` [Try it online!](https://tio.run/##XVHLbsMgEDyXr1hZqgS1EyWW4oNTvsK@WT4QjDEpBQREffx8atJIDd3LakYjzeys@4qLNfX1OokZIg6Vrjq6Iy0CRq2fcBh2I0EwWw8clIEw7NuxRU8fi9IC2CZpOGFmgu5VC4MDeambtivp/sgoZpvmUGryXDdlc0DgRbx4Ax1KZvOqbXs63ExJMtDJwDMjBa4bMh7v8n6rzCQ@8bsyuCfkGkWIASgMCO5TTFYW1R9kUmTQOZ0T2i3sJGLG/U5GnfgaVP7jMugcz5y5nYS0en7kUl7OQpbg@xGc7ZsyskAjQqmGpE9N3O5cH@G8MhEnVK2lpb29OCc8JmsZPw "Python 2 – Try It Online") -22 bytes from [tsh](https://codegolf.stackexchange.com/questions/177404/optimal-alphabet-stepping/177407#comment426829_177407) -39 bytes from [Jo King](https://codegolf.stackexchange.com/questions/177404/optimal-alphabet-stepping/177407#comment426824_177407) Older version with explanation: ``` A=map(chr,range(65,91)).index def t(s,l,S=0): a=A(s[0]) for c in s[1:]: while a!=A(c)and S<len(s)26: S+=1;a+=l;a%=26 return S def f(s):T=[t(s,l)for l in range(26)];return T.index(min(T)) ``` [Try it online!](https://tio.run/##XVFLbsMgFFyXU7xaqgSNFcWWaql2WeQM9s7ygmD8aQlGQNTP5V1wIjX0bdAMozfDoL/dtKh8XY/0zDTmk0kNU6PAxUv6mhGyn1UvvlAvBnDYpjKt6YGUCBg9YtseOgIIhsUAh1mBbbOyK9HD5zRLAezRazhhqof6TQqFLXnOC38N9Y5mFdtRWbEnmhcIjHAXo6DefAYvLBvabn4kLJdh@TVWXpCuusmbazh8nhVuCFmdsM4ChRbBbZJ@GZP0D7JRRFBrGRNST@wkXMRdJ6JO3Acd/3ER1JpHznzpxbjI4Z4LeTmzUYKfe/C@fMxqTFCHUKgh6EMT2zv9H2gzK4cDSn1p4dxftBYGE1/GLw "Python 2 – Try It Online") ~~This would be shorter in a language with a prime number of letters (wouldn't need the `float('inf')` handling of infinite loops). Actually, this submission would still need that for handling strings like "aaa".~~ This submission now uses `26len(s)` as an upper bound, which stops infinite loops. This submission is 0-indexed (returns values from 0 to 25 inclusive). `f` takes a(n uppercase) string and returns the Optimal Alphabet Stepping `t` is a helper function that takes the string and an alphabet stepping and returns the number of hops needed to finish the string (or `26len(s)` if impossible). [Answer] # [Red](http://www.red-lang.org), 197 bytes ``` func[s][a: collect[repeat n 26[keep #"`"+ n]]m: p: 99 a: append/dup a a m u: find a s/1 repeat n 26[v: extract u n d: 0 foreach c s[until[(v/(d: d + 1) = c)or(d > length? v)]]if d < m[m: d p: n]]p] ``` [Try it online!](https://tio.run/##VU7LasMwELz7Kwb3YpODmx4KEX38Q69CUEVaOU5kaZFlU/rzrkqhKLuXmdlhZxLZ/YOsVI0Tu1uDkYuSWsBE78lkmYhJZwQ8PcsbEeOh/WwPCErNAixwOqG4NTMFO9iVocvOzSrgpmALXoYj6iebAH3lpE3GitBYgUe4mEibCwwWuYY8edltQ1dOFgcce7zC9DF1Fm/wFMZ8ecfWKzW5YnjBLOdfZylTWrHaOU0hw6G1cWybf6ZHqhmzv@OeL/pMuZb@plbOxpIb76WaMZs60kRLY/SukjIt2eiljv6u8DXepjC2@w8 "Red – Try It Online") [Answer] # [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~33~~ ~~27~~ 26 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` Ç¥ε₂%U₂L<©ε®₂%Xk'-žm:]øOWk ``` Uses the legacy version because there seems to be a bug when you want to modify/use the result after a nested map in the new 05AB1E version.. 0-indexed output. [Try it online](https://tio.run/##MzBNTDJM/f//cPuhpee2PmpqUg0FEj42h1ae23ponRZIICJbXfdRU4tV7OEd/uHZ//@n5KcDAA) or [verify all test cases](https://tio.run/##MzBNTDJM/V9TVulir6TwqG2SgpL9/8Pth5ae2/qoqUk1FEj42BxaeW7roXVaIIGIbHXdR00tVrW1h3f4h2f/1/mfkp/OlZieypVYUJADJHMKMhKTUku4EiGAKzEpOSU1LR3ESOQqKEhO50rOT0lNz89J4ypJLS5JTixO5ariysrPzsxLBwA). Explanation: ``` Ç # ASCII values of the (implicit) input ¥ # Deltas (differences between each pair) ε # Map each delta to: ₂% # Take modulo-26 of the delta U # Pop and store it in variable `X` ₂L< # Push a list in the range [0,25] © # Store it in the register (without popping) ε # Map each `y` to: ®* # Multiply each `y` by the list [0,25] of the register ₂% # And take modulo-26 # (We now have a list of size 26 in steps of `y` modulo-26) Xk # Get the index of `X` in this inner list (-1 if not found) '-₄: '# Replace the minus sign with "1000" # (so -1 becomes 10001; others remain unchanged) ] # Close both maps ø # Zip; swapping rows/columns O # Sum each W # Get the smallest one (without popping the list) k # Get the index of this smallest value in the list # (and output the result implicitly) ``` [Answer] # [Python 3](https://docs.python.org/3.7/), ~~191~~ ~~178~~ 162 bytes Thanks everyone for all your tips! this is looking much more golflike. ``` w,=map(ord,input()) a=[] for i in range(26): n=1;p=w[0] for c in w: while n<len(w)26and p!=c: n+=1;p+=i; if p>122:p-=26 a+=[n] print(a.index(min(a))) ``` [Try it online!](https://tio.run/##NYvLDoIwEEX3/Ypx1/IwUhMW4PgjhEXDQyaBYdKg1a@vduHdnZxz5XMsO19jzEKBmxO9@7EgluehjVEOu17NuwcCYvCOH5O2tWkUMFatYOguvYIUDCkIPwFhoXUCvq0T62AyWzseQU44JAmcp2OO1CaiGeReWdtIibZW4HLsuFfiiQ/tzsTj9NYbsXbGmBjdf7F8rV8) [And my original code](https://tio.run/##RYvBCsIwEETv@Yr1llBb2ghKhfRHSg@xTXWxbpdQjX59bFQQBoZ5M8Ov5TLTLsZg2tkPslcwzh56QFrF90WqTljTdiJhTNhbOjtZbvVBHQWQqQSwCW3Zif81rA2EC04OeGP6lICyNAXgzGByHIGbSutPCZwbvf9haur6S0/e2asAW1hmR4MkJdgjLdIWSIN7yhuStEqpGNfF5GL@mN4) if anyone's interested. Turns the word into a list of ASCII values, then iterates through step sizes 0 to 25, checking how many steps it takes to exhaust the list (there's a ceiling to stop infinite loops). Number of steps is added to the list a. After the big for loop, the index of the smallest value in a is printed. This is equal to the value of i (the step size) for that iteration of the loop, QED. [Answer] # [JavaScript (Node.js)](https://nodejs.org), 85 bytes ``` s=>(b=Buffer(s),g=i=>s[g[j=i%26]=g[j]+!((b[0]-b[g[j]]+~~(i++/26)j)%26)\|\|1]?g(i):j)`` ``` [Try it online!](https://tio.run/##dZFva4MwEMbf71NkwiCZ7ayWCRukY/saIjR/LlmcM8HY0Y3Sr@60WhCl9yKEu9899@RSsB/mRW1cs66shFbR1tMd5vTjoBTU2JOVpobufKazgpqHJM1pd8vDe4x5tsnXvC/keXg@YxOGUZKSx4J0GDmd4vxNY0NeC7Lft8JW3pbwVFqNFQ6k1QHqgxAURSiO72YA0zAF0kXdufJCjAIvC6B0n4xDEwzAsj5EMApskLJ1d5pKwhHkCiXpJRNfM4t@LiQozUb9GHXwcghn01e8V7/ISomqwzeHGsFRgGuGMdt5q3NiWNGo/zwHRPdf2pYquAU04BvBPNzawN9gbWpuMDYHC/tlqt7MddftPw "JavaScript (Node.js) – Try It Online") Branch First Search, needn't handle infinite loop # [JavaScript (Node.js)](https://nodejs.org), 83 bytes ``` s=>(b=Buffer(s),g=i=>s[g[j=i%26]=g[j]+!((b[0]-b[g[j]]-~(i++/26)j)%26)\|0]?g(i):j)`` ``` [Try it online!](https://tio.run/##dZHbSsQwEIbvfYpYEBK7tYfFgkJW9DVKYXOYxNTahKYrq4ivXrvbLpSWnYsQZr7558@kYl/Mi9a4LmqshF7R3tMd5vTtoBS02JONpobufKGLipq7LC/pcCvDW4x5kZQRPxXKMvrDJgzjLCf3FRko8puULxob8lyR/b4XtvG2hofaaqxwIK0O0CkIQXGM0vRmATANcyBf1Z2rz8Qk8LQCavfOOHTBCKzrYwSTQIKUbYfTNBKOIDcoy8@Z9JJZ9XMhQWk26adogNdDOJu/4rX5RlZK1Bw@ObQIjgJcN47ZLludE@OKJv3HJSCG39K2VsE1oAPfCebh2gZ@Rmtzc6OxJVjZD9OczFx23f8D "JavaScript (Node.js) – Try It Online") Assumes even is always better than odd if possible, 13 is always better than other if possible, which seems correct # [JavaScript (Node.js)](https://nodejs.org), 82 bytes ``` s=>(g=i=>s[g[j=i%26]=g[j]+!((b[0]-b[g[j]]-~(i/26)*j)%26)\|0]?g(-~i):j)(b=Buffer(s)) ``` [Try it online!](https://tio.run/##dZHbSsQwEIbvfYpYEBK19iAWFLKir1F6kcMkptYmNF1ZRfbVa7vpQmnZuQhh5pt//kxq9s286Izr49ZKGBQdPN1hTQ3d@VKXNTU3eVHR8VbdXWPMy7SK@VSoqviITZIX5LYmI0P@0upV4/hoyEtNMKfve6Wgw56QQdjW2wYeGquxwpG0OkJTEIKSBGXZ1QpgGpZAsak715yIWeB5AzTug3HoowBs6yGiWSBFynbjaVoJB5D3KC9Omeyc2fRzIUFpNutnaIS3QzhbvuKt/UFWStTuvzh0CA4CXB/GPK5bnRNhRbP@0xoQ42dp26joEtCD7wXzcGkDv8Ha0lwwtgZr@2naycx518M/ "JavaScript (Node.js) – Try It Online") Less confident about correctness ]
[Question] [ Seahorses, of course, need shoes. However, a seahorse, having just one tail, needs just one shoe. Unfortunately, the shoes only come in pairs. Money is tight for the seahorse government, so they need to buy as few pairs as possible. Each seahorse has a shoe size x where x is a positive integer. However, a seahorse can wear a shoe of size x - 1 or x + 1 if need be. Your task is to output the minimum number of pairs the seahorse government must buy to put shoes on all their seahorses. You may take input however you want, standard loopholes, etc. As this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest code in bytes wins. ## Test cases ``` 2 4 6 6 8 14 -> 4 2 1 3 1 1 -> 3 4 1 4 9 1 8 9 1 8 4 -> 6 1 2 3 5 7 8 10 12 -> 4 ``` [Answer] ## [Husk](https://github.com/barbuz/Husk), ~~15~~ 14 bytes ``` Γ0(→₀?tI↑<+3)O ``` Uses the greedy algorithm: sort and pair from the left. [Try it online!](https://tio.run/##yygtzv6vkHti/aOmxtzM8kPb/p@bbKDxqG3So6YG@xLPR20TbbSNNf3///9vpGCiYAaEFgqGJlxGCoYKxkBsyGUCJE0ULIGkBZQ04TJUMALKmiqYgxQbKBgaAQA "Husk – Try It Online") Thanks to Leo for saving 1 byte. ## Explanation This is the first Husk answer that uses `Γ`, the function for pattern matching a list. In this use case, if `a` is a value and `g` is a function, then `Γag` corresponds to the function `f` defined by the Haskell snippet ``` f [] = a f (x:xs) = g x xs ``` I define the base case as `a = 0` and ``` g x xs = 1 + line0 (if head xs < x+3 then tail xs else xs) ``` where `line0` refers to the entire line. In the Husk code, `x` and `xs` are implicit arguments to the lambda function, and `line0` is `₀`. The list is sorted again in each recursive call, but that doesn't matter in a golf challenge. ``` Γ0(→₀?tI↑<+3)O O Sort Γ and pattern match 0 giving 0 for an empty list ( ) and applying this function to a non-empty list: +3 Add 3 to first argument (x), < make a "test function" for being less than that, ↑ take values from second argument (xs) while they pass the test. ? If that prefix is nonempty (next value can be paired), t take tail of xs, I otherwise take xs as is. ₀ Apply the main function (line0) to this list → and add 1 for the singleton/pair we just processed. ``` [Answer] # [Python 2](https://docs.python.org/2/), 49 bytes ``` f=lambda a:a>[a.sort()]and-~f(a[[3+a.pop(0)]>a:]) ``` [Try it online!](https://tio.run/##XYzBCsIwEETvfoXHDa6lSROtBfsjIYeVEhQ0CTUXL/56XMGDCcsMzCzz0itfY1Cl@POdHpeFtjTRbKl7xjWDcBSW/dsDWTvsqEsxQS/cTJMTJa23kMGDVajxwDei1E6Izd9D4sCSVau50XhiH39eryQqXhk8foE9StUwTZVNQ1dNZhrn8gE "Python 2 – Try It Online") Based on [Leaky Nun's recursive solution](https://codegolf.stackexchange.com/a/132372/20260). --- [Python 2](https://docs.python.org/2/), 59 bytes ``` p=c=0 for x in sorted(input()):c+=x>p;p=(x>p)(x+2) print c ``` [Try it online!](https://tio.run/##LUtLDsIgEN1zCsIK2lkUBEUNXsR0hRi7gQligqfHaWIm7zd5D7/tVbIZqacohBgYYljYs1Te@Zb5u9SWHnLL@GlSqUucQ7/hFYMkUZPss1EM65Ybj4P2kxt3AxaOdB60XRlFDQeCJm9JLZyJ/Z/3hgZDDQenfbKANvRz4Ncf "Python 2 – Try It Online") Iterates through the sizes `x` in sorted order. Remembers the upper threshold `p` for the current size to the paired with the previous one. If so (`x>p`), reset the threshold to `0` to make it impossible for the next one to be paired. If not, increment the output count `c` and set the next threshold `p` to `x+2`. The new threshold `p=(x>p)(x+2)` is a bloated expression. I'd like to find a way to shorten it. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes Uses the approach OP described in the comments. ``` {¥3‹J0¡€gÌ2÷O ``` [Try it online!](https://tio.run/##MzBNTDJM/f@/@tBS40cNO70MDi181LQm/XCP0eHt/v//RxvqKBjpKBjrKJjqKJjrKFjoKBgaALFRLAA "05AB1E – Try It Online") ### Explanation ``` {¥3‹J0¡€gÌ2÷O Argument l { Sort l ¥ Push deltas 3‹ Map to lower than 3 (1 for true, 0 for false) J0¡ Join and split on 0 €g Map to length Ì Each + 2 2÷ Integer division by 2 O Sum ``` [Answer] # [Python 3](https://docs.python.org/3/), ~~69~~ ~~66~~ 60 bytes 9 bytes thanks to xnor. ``` f=lambda a:a[1:a.sort()]and-~f(a[1+(a[1]-a[0]<3):])or len(a) ``` [Try it online!](https://tio.run/##VYwxDsIwDEV3TtExFi6qmwAlgpNEGYxKBFJJqpCFhasHV2Kgsv4b3tf3/C73FHWt4TLx8zpyw5YdWd69Ui4KPMex/QQlbrvAt@w6f9ZgPaTcTLeoGOqcH7GooFyPBg9yA5LxAJu/glBLaGWNGIMn4fDjekXYy2qPx@Vhh9RLW78 "Python 3 – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~20~~ 18 bytes ``` ṢLµIḢ<3+2⁸ṫß‘µLỊ$? ``` [Try it online!](https://tio.run/##y0rNyan8///hzkU@h7Z6PtyxyMZY2@hR446HO1cfnv@oYcahrT4Pd3ep2P8/3P6oac3//9FGOiY6ZkBooWNoEqsD5BrqGAOxIZBtAqRNdCyBpAWUBKkw1DECqjDVMQdpMdAxNIoFAA "Jelly – Try It Online") Fork of my [Python answer](https://codegolf.stackexchange.com/a/132372/48934). [Answer] ## C#, ~~111~~ ~~108~~ ~~137~~ 102 bytes This will never win but I wanted to solve the exercise anyway: ``` Array.Sort(a);var c=0;for(var i=0;i<a.Length;i++){c++;i+=a.Length-i>1&&a[i+1]-a[i]<3?1:0;}Console.WriteLine(c); ``` Thanks to the comment of @grabthefish, I was able to nibble of a few more bytes: ``` Array.Sort(a);int c=0,i=0;for(;i<a.Length;i++){c++;i+=a.Length-i>1&&a[i+1]-a[i‌]<3?1:0;}Console.Wri‌teLine(c); ``` Following the PC&G special C# rules: ``` class P{static void Main(){Array.Sort(a);int c=0,i=0;for(;i<a.Length;i++){c++;i+=a.Length-i>1&&a[i+1]-a[i]<3?1:0;}Console.WriteLine(c);}} ``` Using a lambda function: ``` a=>{System.Array.Sort(a);int c=0,i=0;for(;i<a.Length;c++)i+=a.Length-i>1&&a[i+1]-a[i]<3?2:1;return c;} ``` [Answer] ## Perl, 113 bytes ``` say sub{for(1..$#_){$x{$i}++;$i++if$_[$_]-$_[$_-1]>2}$x{$i}++;$-+=$_/2+$_%2for values%x;$-}->(sort{$a<=>$b}@ARGV) ``` Takes list of arguments from command line (as `@ARGV`), prints to `STDOUT` by default. ## In Seahorseville... A *neighbourhood* is a sequence of neighbouring shoe sizes. When sorted, each seahorse has immediate neighbours that can share the same shoe size. There can be multiple neighbours in the neighbourhood and no neighbours can differ in value by more than two: e.g. `3 3 4 5 5 6` is a single neighbourhood, as are `2 4 6 6`, and `1 2 3 5 7 8 10 12` e.g. `1 1 1 4 5 6` contains two neighbourhoods: `1 1 1` and `4 5 6`. ## Basis of the algorithm There are two types of neighbourhood: * *Even-sized* For these, `n/2` pairs is always sufficient: e.g. `3 3 4 5 5 6` requires three pairs for `3 3`, `4 5` and `5 6` * *Odd-sized* For these, `ceil(n/2)` pairs is always sufficient: e.g. `12 13 13 14 15` requires three pairs for `12 13`, `13 14`, and `15` alone. ## Ungolfed code to test the algorithm ``` sub pairs { @_ = sort { $a <=> $b } @_; my @hood; my $i = 0; for (1..$#_) { push @{$hood[$i]}, $_[$_-1]; $i++ if $_[$_]-$_[$_-1]>2 } push @{$hood[$i]}, $_[$#_]; my $pairs; $pairs += int(@{$hood[$_]} / 2) + @{$hood[$_]} % 2 for 0..$#hood; return "$pairs : @{[map qq([@$_]), @hood]}\n"; } ``` ## Sample Results (Neighbourhoods enclosed in `[ ]` ) ``` 4 : [2 4 6 6 8] [14] 3 : [1 1 1 2 3] 6 : [1 1 1] [4 4 4] [8 8 9 9] 4 : [1 2 3 5 7 8 10 12] 17 : [1 2 3] [6 8 9 11 13 13 15 17 19 20 21] [27 28 29 30 32 33 35 35] [38 38 40] [43 45 45 46] [49] 18 : [3 3 3] [8 10 11 11 11 12 14] [18] [21 22 23] [29] [32 33 34 34 34 35 37 38 39 41] [44 46 48 49 49] 18 : [1 2 3] [6] [9] [12 13 15 17 18 19 20 21 21 23 24 25 25] [35 36] [40 41 41 41 43 45 46 46 46] [49] 16 : [1 3] [6 6 6 6] [11 12 14 14 15 17 19 20 20 21 21 22] [25 25 27 29 31 32 33] [38 39] [44 45] [49] 16 : [2 4] [7 7 8 10 12 13 15 16] [22 22 24 24] [27 29 31 31 33 34] [37 38 39] [42 43 43 44 45 46 47] 17 : [2 4 5 6 7] [11 11 13 13 14 15 16 17 17 17 19] [29] [34 35 36] [39 39 41 41 41 42 44 46] [49 49] 18 : [3 4 5 7 7] [10 10 12 12 12 14 15 15 17 18] [21] [24 24] [28] [32] [39 40 41 42 43 44 44] [47 47] [50] 16 : [2 4] [7 7 8 8] [11 11] [14 16 17 17 18 19] [22 24 26 26] [30 31 33 34 34 35] [38 38 39] [42 43] [50] 16 : [1 3 4 5] [11 11] [15 15 17 18 19 21 22 23 23 25 27 27 27 27 28 29 30 30] [33 34] [41 41] [45] [48] 17 : [2 2 3 4 6 6 7] [10 10] [13 14 15 16 17 19] [23 25] [28 30 31 32 33 34 36 37 38] [42] [48 49 50] 17 : [2] [7 9 9 9 9 10 10 12] [16 16] [19 21 21 22 24] [27 27 27] [36 36 36 37 39 39 40 40 40 41] [46] 18 : [1] [5 6 6 8] [11 11 12] [19 19 20 21 22 24 26 26] [29 30 31 32 34 35 35] [38] [42] [45] [48 48 49 49] 16 : [2 4 4 6] [11 12 13 13 13] [21 21 21 23] [30 31 31 33 35] [41 41 41 43 45 46 47 48 48 49 49 50] 16 : [2 2] [8 10 12] [15 15 15 15 16 16] [19 20] [23 24] [28 28 29] [32 34 36 36 36 37 39 41] [44 45 47 48] 17 : [3 3] [6] [9 10 11] [17 18] [21 23 23] [27 28 29 29 30 31 31 33] [37 37 39 39 39 40] [43 44] [47 48 49] 17 : [4] [7 9 10 10] [14 14 14] [17] [21] [25 25 27 27 28 30] [33 35 37 37 38 40 41 43 44 45 47 48 49 50] 18 : [3 4 5 6 7] [10 11 12 12 14 15 16 17] [20] [23 24 25 25 26 26] [31] [35] [38 40 41 42] [45 46 47] [50] 17 : [1 3] [8 10] [16 16 18 19 20 20] [23 23] [26] [30 31 33 34 35] [39 39 39 40 41 42 43] [46 46 47 47 49] 18 : [2 4 4 4 4 6 7 8 8 10 10] [13] [16 17] [20 22 23 25 25] [29 29 29] [33] [39 40 42] [48 48 49 49] 16 : [1 1 3 4] [7 8 10 10] [18 18 20 21] [24 25 26 27 29 31 33 33 34 34] [37 37 39] [45 46 48 49 49] 17 : [1] [4 4] [7 9 9 11 12] [15 16 17 17 18 19 21 21 21 22 23] [27 28 30 31] [37 39] [42] [48 49 49 50] 17 : [3 4 6 7 7 8 9 10 10 11 13 14 14] [21 21 23] [26 27] [31 32] [35 36] [39 40 41 41 41] [44 44] [49] 16 : [1] [4 6 6 8 10 12 13 15] [20 20 21 21] [29 29 30] [34 36 36 37 37 38 38 40] [44 45 46 47 47 48] 17 : [3 4 4 6] [12 14 15 16 17] [20 21 22 22 22 23 24 26 26] [29 30 32] [35 37 37 37 38 39 41 42] [48] 19 : [1] [5] [8 9] [14 14 14 16 16 17 17 17 17] [21] [24 24 24] [30] [34 35 36 37 39 40 40] [45 46 46 47 48] ``` [Answer] # Mathematica, 67 bytes ``` Length@Flatten[Partition[#,UpTo@2]&/@Split[Sort@#,Abs[#-#2]<3&],1]& ``` Try in [Wolfram sandbox](https://sandbox.open.wolframcloud.com "Wolfram sandbox"). [Answer] # [K (ngn/k)](https://bitbucket.org/ngn/k), 31 bytes ``` {#,/0N 2#/:(0,&~t)_t:3>-':x@<x} ``` [Try it online!](https://tio.run/##y9bNS8/7/z/NqlpZR9/AT8FIWd9Kw0BHra5EM77EythOV92qwsGmovZ/mrqGkYKJghkQWigYmlgbKRgqGAOxobUJkDRRsASSFlDSxNpQwQgoa6pgDlJsoGBopPkfAA "K (ngn/k) – Try It Online") * `x@<x` sort the input (ascending) * `t:3>-':` generate boolean array indicating where the difference between values is less than 3, storing in `t` * `(0,&~t)_t` split `t` on where 0's are present, e.g. `1 1 1 0 1 1 0 1 1 1` => `(1 1 1;0 1 1;0 1 1 1)` * `0N 2#/:` split each of the right-side arguments into length 2 chunks (i.e. valid "pairs" of shoes) * `#,/` flatten the chunks and take their count [Answer] ## Perl, 103 bytes ``` say sub{for(1..$#_+1){$x{$i}++;$i++if$_[$_]-$_[$_-1]>2}@_/2+.5grep$_%2,values%x}->(sort{$a<=>$b}@ARGV) ``` Takes list of arguments from command line (as `@ARGV`), prints to `STDOUT` by default. This is an alternative approach, based on the following relationship: ``` Minimum pairs = ( Population size + # Odd neighbourhoods ) / 2 ``` (See [this answer](https://codegolf.stackexchange.com/a/132505/2771) for how neighbourhood* is defined) [Answer] # Javascript, 67 bytes ``` a=>(a=a.sort((a,b)=>a-b)).filter((n,i)=>m=!m\|n-a[i-1]>2,m=0).length ``` Example code snippet: ``` f= a=>(a=a.sort((a,b)=>a-b)).filter((n,i)=>m=!m\|n-a[i-1]>2,m=0).length v=[[2,4,6,6,8,14],[2,1,3,1,1],[4,1,4,9,1,8,9,1,8,4],[1,2,3,5,7,8,10,12]] for(k=0;k<4;k++) console.log(`f([${v[k]}])=${f(v[k])}`) ``` [Answer] # [J](http://jsoftware.com/), 29 28 bytes ``` [:#(([#~_2>-&{.),_:0}])/@/:~ ``` [Try it online!](https://tio.run/##TYxPC4JAEMXvfopHQrmku85qVhtGf6BTdOiqISKFdMiQbpVf3ab0EMN7M/yY967tQI4uiA1GcOHDsDyJ7XG/axNjO05iN5leesOnFG5m/PdJqJUyTSusw0Zifase5blGfr/XVV6U5kdtj2zpO2z6NVapWMiMVq52gqUnVJqaxrLORVkhRIwLNO@IZwYKOx70nPgiUAejH@RfYs3ZZ72H/2XEsQATTL91Pki3Hw "J – Try It Online") Basic idea: * `/:~` Sort. * `(...)/` Fold from the right, collapsing pairs into the single value infinity `_`, and appending the new value otherwise. * `[:#` Return the length of the result. Specifically, step 2 works like this: * `_:0}]` Update the first element `0}` of the right-hand fold argument `]` (the list we're "building", the "memo" of the reduce, etc) to infinity `_:`. * `_2>-&{.` When the difference between the left-hand fold argument and the first element of the right-hand fold argument is less than negative 2 `_2`, append the left-hand argument `[#~...,`. This condition will hold when either: + The values are too far apart to wear the same shoe. + The previous value was already "used up" by a preceding pair. The right argument will always be infinity in this case. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 13 bytes ``` Ṣ3+þŒpŒɠ€HĊ§Ṃ ``` [Try it online!](https://tio.run/##y0rNyan8///hzkXG2of3HZ1UcHTSyQWPmtZ4HOk6tPzhzqb/h9uBvP//o7mijXRMdMyA0ELH0CRWB8Q31DEGYkMQxwTIMNGxBJIWUBKsxlDHCKjGVMccpMtAx9AIKBgLAA "Jelly – Try It Online") # Explatation ``` Ṣ3+þŒpŒɠ€HĊ§Ṃ Main monadic link Ṣ Sort 3+þ Add [1,2,3] to each element Œp Cartesian product Œɠ Run lengths € of each sublist H Halve all numbers Ċ Ceil all numbers § Sum each sublist Ṃ Minimum ``` ]
[Question] [ Given a positive number n, output all distinct multiplicative partitions of n in any convenient format. A multiplicative partition of n is a set of integers, all greater than one, such that their product is n. For example, 20 has the following distinct multiplicative partitions: ``` 2 * 2 * 5 2 * 10 4 * 5 20 ``` Order does not matter, so `2 * 2 * 5` is the same partition as `2 * 5 * 2`. --- Examples: ``` 1 -> {} 2 -> {2} 4 -> {2, 2}, {4} 20 -> {2, 2, 5}, {2, 10}, {4, 5}, {20} 84 -> {2, 2, 3, 7}, {2, 2, 21}, {2, 14, 3}, {2, 6, 7}, {2, 42}, {4, 3, 7}, {28, 3}, {4, 21}, {6, 14}, {12, 7}, {84} ``` [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 16 bytes ``` >~l:{1<}a.?,.=o ``` This is a function* (not a full program) which takes a positive number as input and [generates](http://meta.codegolf.stackexchange.com/a/10753/62131) all multiplicative partitions of it. (I also avoided using any prime factorization builtins in this solution, mostly because I wasn't sure they'd help; I might try a more builtin-heavy solution too at some point.) [Try it online!](https://tio.run/nexus/brachylog#@19tV5djVW1oU5uop2Wvo2ebX1se8/@/kQEA "Brachylog – TIO Nexus") (Extra code has been added around the function here to make it into a full program; if you provide the function shown above to TIO directly, it will run the function but not print its output anywhere, which is kind-of useless as a demonstration.) This program really disappoints me, because much of it is working around bugs in the Brachylog interpreter and deficiencies in its specification, rather than actually solving the problem; but the interpreter is what it is. (Even with the program like this, the interpreter uses much more memory than it logically should, and crashes due to memory exhaustion, but luckily on small problems it manages to produce the desired output first.) In a hypothetical "perfect version of Brachylog" you could just write `~.o.:{>1}a,`, which would be 4 bytes shorter, but I needed to add extra constraints to help the interpreter out a bit. (I don't really like Brachylog much, and would rather stick to Prolog, but it needed similar hints to make the program work and they're much longer to write. So Brachylog it is.) Explanation: As usual, a Brachylog program is a set of constraints; by default, the first constraint constrains the input against an unknown (which I'll call A), the second constraint constrains A* against a second unknown B, and so on until we reach the output. Some characters, such as `{}`, can change this general flow, so I use a different set of letters (e.g. X/Y) to represent unknowns in nested predicates. ``` > A is smaller than the input ~l B has length A 1< X is 1, Y is larger :{1<}a For each element X of B, it corresponds to an element Y of C . C, the output, and D are all identical * E is the product of D's elements ? E, the input, and F are all identical , There's no constraint between F and G . G, the output, and H are all identical = H and I are identical, and need to be evaluated early o The output can be produced by sorting I ``` It's still unclear how the program works, so let's try simplifying the constraints a bit. C, D, G, H, and I are all the same (and equal to the output). E and F are also the same (and equal to the input). So our constraints boil down to this: * A is the length of B and of the output, and is smaller than the input. * B consists of all 1s, and isn't particularly useful (it's part of the program simply because in the existing Brachylog interpreter, `:{1<}a` needs its left argument to have a constrained length, or else the interpreter goes into an infinite loop). * The output consists entirely of numbers greater than 1 (i.e. greater than the corresponding element of B). * The product of the elements of the output is equal to the input. * The output is unchanged by sorting it (i.e. is in sorted order). Incidentally, I didn't explicitly specify that all the elements of the output are integers, something which might seem to be required; however, Brachylog's constraint solver can't handle non-integers, so it'll conveniently produce only the solutions that involve integers. Clearly, "the length of the output is smaller than the input" is going to be true whenever the output is a multiplicative partition of the input (because 2x > x for all nonnegative x, i.e. positive 2x). So we can disregard that constraint; it's only there to give the Brachylog interpreter a working strategy for evaluating the program. The other constraints (that the output is sorted, that its product is the input, and that its elements are all greater than 1) are the definition of a multiplicative partition, and therefore this function is basically just a direct implementation of the question. [Answer] # [Brachylog](https://github.com/JCumin/Brachylog) 1, 14 bytes ``` :{$pp~c:ao}fd ``` [Try it online!](https://tio.run/nexus/brachylog#@29VrVJQUJdspZWYX5uW8v@/hcn/KAA) # [Brachylog](https://github.com/JCumin/Brachylog) 2, ~~11~~ 10 bytes, language postdates challenge ``` {ḋp~c×ᵐo}ᵘ ``` [Try it online!](https://tio.run/nexus/brachylog2#@1/9cEd3QV3y4ekPt07Ir324dcb//xYm/6MA "Brachylog – TIO Nexus") Maltysen answered this question in 17 bytes of Pyth, so I came up with a 16-byte Brachylog solution that worked by translating the specification of the question to Brachylog. While I was doing that, Dennis wrote a 15-byte Jelly solution. So I had to go down to 14 bytes. This is a function* that takes the input as an argument, and returns a list of all partitions (rather than a generator, as with my other solution). Some time after I wrote this answer, Dennis and I managed to cooperatively get the Jelly solution down to 11 bytes. It turns out there's a new version of Brachylog out, with a terser syntax; it postdates the challenge, so doesn't actually count, but it could manage the 11-byte total too pretty much as soon as it released; later revisions of the language (inspired by other challenges) can go as low as 10, as seen here. The two programs are identical, with the only difference being the syntax. Unlike my other solution, which didn't make much use of "golfing primitives" but rather stated the problem directly, this one ignores pretty much all the power of Brachylog constraints and does its best Jelly impression instead, writing a chain of constraints for which the left argument is already known (and thus the constraints simply act like Jelly monads rather than full-blown constraints). It therefore uses the same algorithm as @Maltysen's Pyth solution, which is probably the easiest way to solve this using typical golfing primitives. (Interestingly, the "just state the problem" solution in my other answer would be shorter if not for bugs/deficiencies in the Brachylog interpreter, despite its lack of use of golfing primitives. Some day I need to write an "improved Brachylog" in order to get a good solution for this kind of problem; as golfing languages go, Brachylog is actually really verbose.) The program consists of a generator, and a wrapper around it. First, here's an explanation of the generator: ``` $pp~c:ao ḋp~c×ᵐo $p ḋ Prime factor decomposition of the input p p Generate all permutations ~c ~c Generate all inverse concatenations (i.e. partitions) :a ×ᵐ Take the product of each list element in each partition o o Sort each partition ``` This almost solves the problem, but we end up generating many of the partitions many times each. So we need a wrapper to deduplicate the solutions: ``` :{…}fd :{…}f Convert generator to list d Remove duplicate elements {…}ᵘ Convert generator to list of unique elements ``` [Answer] ## Mathematica, 61 bytes ``` ±1={{}} ±n_:=Union@@(Sort/@Append[n/#]/@±#&/@Most@Divisors@n) ``` Defines a (recursive) unary operator `±` which returns the list of partitions. [Answer] # Pyth - 17 bytes Takes all permutations of the prime factorization, then partitions each one and then products all the partitions, then only retains distinct partitions. ``` {mS-Md1s./M.p+1P ``` [Test Suite](http://pyth.herokuapp.com/?code=%7BmS-%2aMd1s.%2FM.p%2B1P&test_suite=1&test_suite_input=1%0A2%0A4%0A20%0A84%0A12345&debug=0). [Answer] ## Python 2, 70 bytes ``` f=lambda n,k=2,l=[]:n/k and(n%k<1)f(n/k,k,l+[k])+f(n,k+1,l)or 1/n[l] ``` Outputs a list of sorted lists. For example `f(20)` is `[[2, 2, 5], [2, 10], [4, 5], [20]]`. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~14~~ ~~13~~ 11 bytes ``` Ḋx³ŒPQP=¥Ðf ``` [Try it online!](https://tio.run/nexus/jelly#@/9wR1fFoc1HJwUEBtgeWnp4Qtr///9NAA "Jelly – TIO Nexus") I was fairly sure @Dennis's Jelly solution could be improved. Unfortunately, I didn't manage to beat the Brachylog record, but I did manage to tie it. Update: With @Dennis' help, it's improved now; I guess Jelly takes back the crown. This program is incredibly inefficient, having O(2n2) performance (which is why the test case above shows it for input 4). It completes quickly on 4, very slowly on 5, and may not be practically possible to run for larger numbers. Interestingly, the Brachylog was improved by going from a solution that described the problem (which Brachylog is good at) to a solution that used an algorithm based on factorising the input (which Jelly is good at); meanwhile, the Jelly solution was improved by moving away from its* strengths, and going back to a solution that just describes the problem. Explanation: ``` Ḋx³ŒPQP=¥Ðf Ḋ List of integers from 2 to the input (apparently undocumented) x³ Make a number of copies of each that's equal to the input ŒP Take all (possibly noncontiguous) subsequences of that list (!) Q Remove duplicates Ðf Filter, keeping elements where: P= their product is equal to {the original input, by default} ¥ Parse preceding two links as a unit ``` Because the output of `Ḋx` is sorted, each subsequence must also be sorted, and thus we don't have to sort them individually. So the "the same output in different orders is a duplicate" part of the problem, and the "all values in the output are > 1" part of the problem, get solved by the generation. Apart from that, what we're basically doing here is "find all lists for which `P=³`", which we do (in an incredibly inefficient way) by generating all the lists in question and then filtering out the incorrect ones. (Clearly, someone needs to go invent a hybrid of Jelly and Brachylog, plus a really good constraint solver, so that we could write something along the lines of `{P=³}~` plus some deduplication code, and solve the program in a much shorter length. That might be some distance away, though.) [Answer] # JavaScript (ES6), ~~74~~ 67 bytes ``` f=(n,m=2,a=[])=>n>1?m>n?[]:f(n,m+1,a).concat(f(n/m,m,[...a,m])):[a] for (var i = 1; i < 31; i++) console.log(JSON.stringify(f(i))); ``` Directly solves the problem recursively: for each integer m from 2 to n, we take each of the partitions of n / m with a minimum element of m (to avoid duplicate partitions) and append m. (For any m that does not divide n, this gives the empty array, as no arrangement of integers multiplies to a decimal.) We define a base case of the empty array for 1 so as to avoid infinite recursion. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes ``` ḊœċRẎP=¥Ƈ ``` [Try it online!](https://tio.run/##y0rNyan8///hjq6jk490Bz3c1Rdge2jpsfb/hgZB1oZGCjoKh9uPTnq4c4aKgsqjpjUK3kAi8j8A "Jelly – Try It Online") This is fairly slow, timing out for \$n \ge 13\$ on TIO ## How it works ``` ḊœċRẎP=¥Ƈ - Main link. Takes n on the left Ḋ - Dequeue; Yield [2, 3, ..., n] R - Range; Yield [1, 2, 3, ..., n] œċ - For each 1 ≤ k ≤ n, yield the combinations with replacement of length k, choosing from [2, 3, 4, ..., n] Ẏ - Tighten these into a single list of lists ¥Ƈ - Keep those lists for which the following is true: P - The product... = - ...equals n ``` [Answer] # Python2, ~~198~~ ~~191~~ ~~172~~ 180 bytes ``` from itertools import* n=input() for i in range(2,len(bin(n))): for P in combinations_with_replacement(range(2,n),i): if reduce(lambda a,b:ab,P)==n:print(P) print[(n,),()][n<2] ``` A full program. This could be improved a lot, so suggestions are deeply welcome! [@FlipTack](https://codegolf.stackexchange.com/users/60919/fliptack) saved 9 bytes! * [@orlp](https://codegolf.stackexchange.com/users/4162/orlp) saved 19 bytes! Outputs from the range 1 to 31 (inclusive): ``` (1,) (2,) (3,) (2, 2), (4,) (5,) (2, 3), (6,) (7,) (2, 4), (2, 2, 2), (8,) (3, 3), (9,) (2, 5), (10,) (11,) (2, 6), (3, 4), (2, 2, 3), (12,) (13,) (2, 7), (14,) (3, 5), (15,) (2, 8), (4, 4), (2, 2, 4), (2, 2, 2, 2), (16,) (17,) (2, 9), (3, 6), (2, 3, 3), (18,) (19,) (2, 10), (4, 5), (2, 2, 5), (20,) (3, 7), (21,) (2, 11), (22,) (23,) (2, 12), (3, 8), (4, 6), (2, 2, 6), (2, 3, 4), (2, 2, 2, 3), (24,) (5, 5), (25,) (2, 13), (26,) (3, 9), (3, 3, 3), (27,) (2, 14), (4, 7), (2, 2, 7), (28,) (29,) (2, 15), (3, 10), (5, 6), (2, 3, 5), (30,) (31,) ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes ``` ÆfŒ!ŒṖ€;/P€€Ṣ€Q ``` [Try it online!](https://tio.run/nexus/jelly#@3@4Le3oJMWjkx7unPaoaY21fgCQBKKHOxcBycD///9bmAAA "Jelly – TIO Nexus") [Answer] ## Clojure, 91 bytes ``` (defn f[n](conj(set(for[i(range 2 n):when(=(mod n i)0)j(f(/ n i))](sort(flatten[i j]))))n)) ``` Example runs: ``` (map f [20 84]) (#{20 (2 2 5) (4 5) (2 10)} #{(7 12) (2 2 3 7) (2 3 14) (2 2 21) (2 6 7) (6 14) (3 4 7) (3 28) (4 21) (2 42) 84}) ``` The value itself is returned as a single number (not a `list`), others come out as lists. The `n` at the end could be replaced by `[n]` to make it a sequence as well, or `(list n)` to make it a list. [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~58~~ ~~56~~ ~~52~~ 47 bytes ``` #0[#/i,##2,i]~Do~{i,2,#>1\|\|Print@{##2};Min@##}& ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7X9kgWlk/U0dZ2UgnM7bOJb@uOlPHSEfZzrCmJqAoM6/EoRooVWvtm5nnoKxcq/Y/zcE1OSPfQVmtLjg5Ma@umssQqNxEx8hAx8JEx9DAgqv2PwA "Wolfram Language (Mathematica) – Try It Online") Prints the partitions. [Answer] # J, 35 bytes ``` ([:~.]<@/:~@(//.)"$~#\#:i.@!@#)@q: ``` Based on the [solution](https://codegolf.stackexchange.com/questions/86855/partial-factorisations-of-a-positive-integer/108312#108312) to a time-constrained factorization challenge. This version is much more inefficient and runs in factorial time based on the number of prime factors. Creates partitions by generating factoradic numbers. [Try it online!](https://tio.run/nexus/j#@5@mYGuloBFtVacXa@Ogb1XnoKGlr6@nqaRSpxyjbJWp56DooKzpUGjFxZWanJGvkKZgZPD/PwA) (Don't try large values online!) ## Explanation ``` ([:~.]<@/:~@(//.)"$~#\#:i.@!@#)@q: Input: integer n q: Prime factorization ( )@ Operate on them # Length !@ Factorial i.@ Range [0, i) #\ Range [1, i] #: Mixed based conversion - Creates factoradic values ] Get factors ( )"$~ For each factoradic value /. Partition the factors based on equal digits in the factoradic value / Get the product of each block /:~@ Sort it <@ Box it [:~. Deduplicate ``` [Answer] # D, 95 bytes ``` void g(int n,int[]r){for(int i=r[0];ii<=n;i++)(n%i)?0:g(n/i,i~r);r.back=n;r.writeln;}g(n,[2]); ``` Just a recursive solution. In `g(n,r)`, `r` is the partition so far, and `n` is the value still left to break into factors. To get each unordered partition only once, we sort the factors in `r` in non-increasing order. The last element of `r` starts at `2` as the least possible factor, and gets overwritten by `n` in each copy just before each output operation. For `n = 60`, the output is as follows: ``` [3, 2, 2, 5] [2, 2, 15] [3, 2, 10] [5, 2, 6] [2, 30] [4, 3, 5] [3, 20] [4, 15] [5, 12] [6, 10] [60] ``` [Try it online!](https://tio.run/nexus/d#JUpLDoIwEN17CkKC6UiDxIULR@JBCIsqn0yEqRmqLki9OhZYvP@j4WXFRaOrMzHcNXpxAWRx97FUR4MhVjARu4hRGlO3Kk7GWO8ZsH2zCuK355LWG0zzWnRb1IHLSmBqrawNFVLmFdKBrgUjpSkoTghu@aVTfCRNPwGU7G4ez7BL9hVyTc/ow6zLUwU4@/mc/wE "D – TIO Nexus") [Answer] # D, 109 bytes ``` import std.stdio;void g(T)(T n,T[]r=[2]){if(n-1){for(T i=r[0];i*i<=n;i++)n%i?0:g(n/i,i~r);r[$-1]=n;r.write;}} ``` [Try it online!](https://tio.run/##Hcy9CsIwFIbh3avIoHCO/bF1KsbgTXQLGYTa8g1N5Fh0CPHWY3B4pwfeKWeszyCbem1TW0LQ74BJLTQyjcrXo3Vi7NlxxEy@6TnOQYrAiO2cxhFX4zWqiv0Bt@6ykD@hxldYi903vSsq7UewPXRKu/98vcMTx4UG1innHw) ]
[Question] [ Today, November 11, 2015, is [Veterans Day](https://en.wikipedia.org/wiki/Veterans_Day) in the United States. "[Taps](https://en.wikipedia.org/wiki/Taps)" is the [bugle call](http://www.music.army.mil/music/buglecalls/taps.asp) played at U.S. military funerals: (["Taps" on SoundCloud](http://soundcloud.com/vtmiller/taps-bugle-call) from [vtmiller](https://soundcloud.com/vtmiller)) It is a simple melody, only twenty-four notes long and using only four different notes. Here is the sheet music: [![Taps sheet music](https://i.stack.imgur.com/QSYEP.jpg)](https://i.stack.imgur.com/QSYEP.jpg) ([source](http://www.music.army.mil/music/buglecalls/images/taps.jpg)) # Challenge Write a program or function that plays "Taps" or outputs an audio file of "Taps" in any common audio file format (e.g. MP3, WAV, MIDI). It may be played in any key, using any type of instrument or beep noise available to your language. For example, it might sound like a piano instead of a bugle. (Though still only one instrument type should be used.) All twenty-four notes must be played with accurate pitch, duration, and spacing. Someone who is familiar with "Taps" should be able to run your code and easily recognize the song being played. The duration of the melody (from the start of the first note to the end of the last note) must be between 30 and 70 seconds. You may optionally have up to 5 seconds of silence padding the start and/or end of your sound file, so an 80 second file is the longest allowed. You may not, of course, simply download the song online somewhere or extract it from an audio library that happens to have it as as sample. You may, however, use audio libraries that can play/compose individual notes and create audio files. # Scoring This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins. However, for this particular challenge I encourage you to not focus on your byte count, especially at the expense of sound quality. Golf your submissions but allow yourself to be creative with your instrument choice or sound output methodology. This challenge is meant to be about honoring veterans, not about screeching out a barely recognizable version of "Taps". Note that you can embed [SoundCloud](https://soundcloud.com) audio files [directly into posts](http://meta.codegolf.stackexchange.com/q/3616/26997) by just pasting the link on an empty line. If you have a SoundCloud account this would be a great way to share your output. [Answer] # JavaScript, ~~203~~ ~~198~~ ~~196~~ 195 bytes ``` with(new AudioContext)for(t=i=0;n="301093301396202346202346202396331699464390301093"[i++];)with(createOscillator())i%2?l=n/2:(frequency.value=392+n44,connect(destination),start(t+.1),stop(t+=l)) ``` 5 bytes saved thanks to [Dendrobium](https://codegolf.stackexchange.com/users/20519/dendrobium) and 1 thanks to @PatrickRoberts. ## Explanation ``` with(new AudioContext) // use HTML5 audio for( // iterate through the note pitches and lengths t=i=0; // t = current time to place the note n= // n = note pitch (or temporarily length) // This string contains the values of each note alternating between length and pitch // (l1, p1, l2, p2, etc...) // Length value is in 16th notes (1 = 1/16th note, 2 = 1/8th, etc...) // The longer notes are limited to 9 but I think it still sounds OK // Pitch value 0 = G4, 3 = C5, 6 = E5, 9 = G5 (multiples of 3 saves 1 byte) "301093301396202346202346202396331699464390301093" [i++];) with(createOscillator()) // create the note oscillator i%2? // alternate between length and pitch characters l=n/2 // l = length (stored for use in the next iteration) // dividing it by 2 sets the speed to 60 beats per minute // and casts it to a number :( frequency.value=392 // base note = G5 (392hz) +n44, // there is (conveniently) roughly 132hz between each note connect(destination), // send the note's sound through the speakers start(t // schedule the note to sound +.1), // short delay to distinguish two notes of the same pitch stop(t+=l) // schedule the end of the note and increment the time ) ``` Test it here in the browser! Works on [any browser that supports the HTML5 Web Audio API](http://caniuse.com/#feat=audio-api). [Answer] # Mathematica, ~~361~~ ~~287~~ 285 bytes I went for accuracy here. Output is exactly as described in the score, played with the trumpet. You can find the file [here](https://www.dropbox.com/s/lrgxfdga3we9ikk/taps.mid?dl=0). ``` "G" e="E5";c="C5";EmitSound@Sound[SoundNote[#,5/#2,"Trumpet",SoundVolume->#3/17]&@@@{%,8,17,%,24,20,c,2,23,%,8,26,c,24,29,e,2,32,%,12,35,c,12,38,e,6,41,%,12,44,c,12,47,e,6,50,%,12,53,c,12,56,e,2,59,c,8,62,e,24,65,"G5",3,68,e,6,170/3,c,6,136/3,%,2,34,%,8,34,%,24,34,c,2,34}~Partition~3] ``` Thanks to @MartinBüttner for golfing suggestions. [Answer] # Sonic Pi, 899 bytes The timing is a little off, but I think it's ok. Lightly golfed: ``` use_synth:blade use_synth_defaults sustain:0.70,release:0.0 play:G4,release:0.05 wait 0.75 play:G4,sustain:0.25 wait 0.25 hold=rrand_i(3,4) play:C5,sustain:hold,release:0.5 wait hold+0.5 play:G4,release:0.05 wait 0.75 play:C5,sustain:0.25 sleep 0.25 hold=rrand_i(3,4) play:E5,sustain:hold,release:1.25 sleep hold+1.25 play:G4 sleep 0.70 play:C5 sleep 0.70 2.times do play:E5,sustain:1,release:0.25 sleep 1.25 play:G4 sleep 0.7 play:C5 sleep 0.7 end hold=rrand_i(3,5) play:E5,sustain:hold,release:0.75 sleep hold+1 play:C5,release:0.05 sleep 0.75 play:E5,sustain:0.25 sleep 0.25 play:G5,sustain:2.45,release:0.05 sleep 2.5 play:E5,sustain:1,release:0.25 sleep 1.25 play:C5,sustain:1,release:0.25 sleep 1.25 hold=rrand_i(3,5) play:G4,sustain:hold,release:0.5 sleep hold+0.5 play:G4,release:0.05 sleep 0.75 play:G4,sustain:0.25 sleep 0.25 hold=rrand_i(3,5) play:C5,sustain:hold,release:1.5 ``` [Answer] # qb64, ~~100~~ 84 bytes Updated version of old Qbasic, downloadable at <http://www.qb64.net/> Count excludes the spaces, which are not required and only there to split the data into three-note phrases for clarity. ``` PLAY"T99L4C.L8CL1F. L4C.L8FL1A. L4CFL2A L4CFL2A L4CFL1A. L4F.L8AL1>C< L2AFL1C. L4C.L8CL1F." ``` Commands in the play string ``` T99 set tempo to 99 quarter notes per minute (default is 120, only just too short) CDEFGAB play notes in the current octave >< up or down one octave Lx following notes are of note of 1/x duration . extend previous note duration by 50% ``` Golfing history: First post: 4/4 time to 4/2 time, which means I have some whole notes, but no sixteenth notes. Edit 1: Key changed from C (range G-G) to F (range C-C). Now I only have to perform an octave change once, for the high C, which only occurs once, rather than all the low G's as before. Having got rid of all those octave changes, I don't think there's any more to golf. There are total of 20 `L`'s but there is no obvious way to avoid them. The last phrase (11 characters) is the same as the first, but there is no way to insert it twice in under 11 characters. The repeated data would be only 9 characters if the initial `L4` were eliminated (It appears unnecessary as the default note length seems to be quarter note, but it's not documented so I left it in.) [Answer] MATLAB, 338 327 262 258 230 bytes ``` o=@(L,f)sin(pi.112^(f/12))(1:600L)) sound([o(3,-1) o(1,-1) o(12,2) o(3,-1) o(1,2) o(12,4) o(2,-1) o(2,2) o(4,4) o(2,-1) o(2,2) o(4,4) o(2,-1) o(2,2) o(12,4) o(3,2) o(1,4) o(8,6) o(4,4) o(4,2) o(12,-1) o(3,-1) o(1,-1) o(12,4)]) ``` [Answer] # Ruby + beep, 178 bytes ``` f=[260,346,416,499] n=[12,1..4] l=(a="001012012012012123210001310310224224220318440310".chars.map(&:to_i))[24..-1] `beep#{24.times.map{\|i\|" -f#{f[a[i]]} -l#{n[l[i]]}00"}" -n"}` ``` Took me awhile to make this, I think I missed the boat, but whatever. `f` holds the four frequencies used. `n` holds the five note lengths used, in multiples of 16th notes. `a="00101...` holds all the note pitchs followed by all the note lengths, as indexes into the respective arrays. `l` is then set to the 24th indice and onward of `a`. Then a beep command is constructed by iterating through all of the above, and executed [Answer] # SmileBASIC, 73 bytes ``` BGMPLAY"@56T50L2.G8.G16B+G8.<C16E>[G8<C8E4>]2G8<C8EC8.E16G2E4C4>GG8.G16B+ ``` All the notes and timings are correct. I used a trumpet because it's the closest thing in MIDI ``` <audio autoplay controls src="//12me21.github.io/resources/taps.mp3"></audio> ``` [Answer] # Powershell, ~~183~~ ~~175~~ 159 bytes Nostalgia trip, who doesn't like beeps?! ``` foreach($i in 0..23){[console]::beep((196,262,330,392)[(001012012012012123210001-split'')[$i]],(3,1,12,3,1,12,2,2,4,2,2,4,2,2,12,3,1,8,4,4,12,3,1,12)[$i]400)} ``` Explanation (sortof) ``` foreach($i in 0..23) { # foreach loop which ranges from 0 to 23 [console]::beep( # [console]::beep(Pitch, Duration) (196,262,330,392) # the notes in Hertz [ # select which note to use (001012012012012123210001-split'') # -split '' creates an array of [0,0,1,0,1 ...], spaces can be omitted [$i] # select the n-th element ], (3,1,12,3,1,12,2,2,4,2,2,4,2,2,12,3,1,8,4,4,12,3,1,12) # array of durations [$i]400 # duration in milliseconds * 400 ) } ``` This will play in about 45 seconds. This is my first time using Windows' Powershell, any tips on golfing this are welome. # Old versions ## ~~175~~ ``` foreach($i in(0..23)){[console]::beep((196,262,330,392)[(0,0,1,0,1,2,0,1,2,0,1,2,0,1,2,1,2,3,2,1,0,0,0,1)[$i]],(3,1,12,3,1,12,2,2,4,2,2,4,2,2,12,3,1,8,4,4,12,3,1,12)[$i]400)} ``` ## ~~183~~ ``` $d=3,1,12,3,1,12,2,2,4,2,2,4,2,2,12,3,1,8,4,4,12,3,1,12;$n=0,0,1,0,1,2,0,1,2,0,1,2,0,1,2,1,2,3,2,1,0,0,0,1;foreach($i in(0..23)){[console]::beep((196,262,330,392)[$n[$i]],$d[$i]400)} ``` [Answer] # BBC Basic, 111 Download interpreter at <http://www.bbcbasic.co.uk/bbcwin/bbcwin.html> Score excludes whitespace and newlines, which are non-essential and added for readability ``` FORk=1TO24 x=ASC(MID$("')F'Lb(Ke(Ke(KbJhxeI#')F",k)) SOUND1,-9,x DIV74+60,INT(12/1.4^(x MOD7))5 SOUND1,0,1,1 NEXT ``` Fairly standard compression, 1 ASCII character per note. Parameters of `SOUND` are as follows: ``` Channel (always 1 for the purposes of this challenge) Amplitude (negative for on, 0 for off, positive is an envelope index) Pitch (in increments of 1/4 semitone, with middle C at 100) Duration (20ths of a second) ``` The range of the song is 13 notes, even though only 4 are used. To get this range into the 95-number range of printable ASCII, I had to squeeze the duration into an integer range of 7 and take it modulo 7. The following durations (in sixteenths) are used (with the exception of 6 which is never used): 1,2,3,4,6,8,12. To produce these numbers, I hit upon the idea of dividing 12 by a power of `sqrt(2)` (approximated by 1.4) and truncating. The `SOUND1,0,1,1` is an annoyance, costing 12 bytes. It's necessary to provide a pause between notes of identical pitch. [Answer] # C - (Raw: 318 \| WAV: 437) 8-bit (unsigned) mono PCM at 44800 Hz, 33.60 seconds. * [File at mediafire](http://mfi.re/listen/3f61dymbjolja6w/x7cmp.wav) (Note: It gets somewhat loud in there ...) The mezzo forte, fortissimo and forte dynamics are somewhat artistically implemented. The fermatas could be better. Code relies on `unsigned long long` being 8 octets and system little endian. ``` #include<stdio.h> #include<math.h> #ifdef RAW main(){unsigned long long D[]={0x422422c13c13,0xc13c44813c22},X[]={27863,37193,46860,55727},O=0x406e64924910,i=0,j;float Z,A,U=40,P;for(;i<24;D[i++/12]>>=4){Z=X[O&3]/1e6;P=0;O>>=2;A=i>18?--U:i<14?U+i/2:U+30;for(j=(D[i/12]&15)13440;j;A-=--j<7e3&&A>0?.01:0)putchar(Asin(P+=Z)+128);}} #else main(){unsigned long long D[]={0x422422c13c13,0xc13c44813c22},X[]={27863,37193,46860,55727},O=0x406e64924910,i=0,j;float Z,A,U=40,P;int W[]={0x46464952,1570852,0x45564157,544501094,16,65537,44800,44800,524289,0x61746164,1505280};fwrite(W,4,11,stdout);for(;i<24;D[i++/12]>>=4){Z=X[O&3]/1e6;P=0;O>>=2;A=i>18?--U:i<14?U+i/2:U+30;for(j=(D[i/12]&15)13440;j;A-=--j<7e3&&A>0?.01:0)putchar(Asin(P+=Z)+128);}} #endif ``` Compile and run with something like: ``` gcc -std=c99 -o taps taps.c -lm ./taps > taps.wav play taps.wav ``` Add `-DRAW` to compile-line for raw variant. Raw output can be played with e.g. SoX `play` as: ``` play -c 1 -b 8 -r 44800 -t u8 <file> \| \| \| \| \| \| \| +--- Unsigned 8-bit \| \| +----------- Sample rate \| +------------------- 8 Bits +------------------------ 1 Channel ``` ]
[Question] [ Sometimes when I'm doodling, I draw a rectangle, start with a diagonal from one of the corners, and then just trace out a line by "reflecting" it whenever I hit a side of the rectangle. I continue with this until I hit another corner of the rectangle (and hope that the aspect ratio of my rectangle was not irrational ;)). This is like tracing out the path of a laser shone into a box. You're to produce the result of that with ASCII art. As an example, consider a box of width `5` and height `3`. We'll always start in the top left corner. The `#` marks the boundary of the box. Note that the width and height refer to the inner dimensions. ``` ####### ####### ####### ####### ####### ####### ####### #\ # #\ # #\ \# #\ /\# #\ /\# #\/ /\# #\/\/\# # \ # # \ /# # \ /# # \/ /# # \/ /# #/\/ /# #/\/\/# # \ # # \/ # # \/ # # /\/ # #\/\/ # #\/\/ # #\/\/\# ####### ####### ####### ####### ####### ####### ####### ``` ## The Challenge Given the (positive) width and height of the box, you should produce the final result of tracing out the laser. You may write a program or function, taking input via STDIN (or closest alternative), command-line argument, function argument and output the result via STDOUT (or closest alternative), or via function return values or arguments. You may use any convenient list, string or number format for input. The output must be a single string (unless you print it to STDOUT, which you may of course do gradually). This also means you can take the height first and the width second - just specify the exact input format in your answer. There must be neither leading nor trailing whitespace on any line of the output. You may optionally output a single trailing newline. You must use space, `/`, `\` and `#` and reproduce the test cases exactly as shown. ## Test Cases ``` 2 2 #### #\ # # \# #### 3 2 ##### #\/\# #/\/# ##### 6 3 ######## #\ /# # \ / # # \/ # ######## 7 1 ######### #\/\/\/\# ######### 1 3 ### #\# #/# #\# ### 7 5 ######### #\/\/\/\# #/\/\/\/# #\/\/\/\# #/\/\/\/# #\/\/\/\# ######### 22 6 ######################## #\ /\ /\ /\ /\ /\ # # \/ \/ \/ \/ \/ \# # /\ /\ /\ /\ /\ /# #/ \/ \/ \/ \/ \/ # #\ /\ /\ /\ /\ /\ # # \/ \/ \/ \/ \/ \# ######################## ``` [Answer] # Pyth, ~~43~~ ~~41~~ 39 bytes ``` K\#+2QKVvzp<QXXdyivzQN\\_hN\/Q\#\#)K ``` Try it online: [Pyth Compiler/Executor](https://pyth.herokuapp.com/?code=K%5C%23%2B2QKVvzp%3CQXXdyivzQN%5C%5C_hN%5C%2FQ%5C%23%5C%23)K&input=6%0A22&debug=0). Input the numbers in the following order: height first line, width second line. Thanks to isaacg, who helped saving two bytes. ## Explanation: My solution doesn't trace the laser, it uses a simple pattern that includes the gcd. If `m, n` are the dimensions of the box, let `d = gcd(m, n)`. The size of the pattern is exactly `2d x 2d`. E.g. the repeating pattern for `7 5` ``` ######### #\/\/\/\# #/\/\/\/# #\/\/\/\# #/\/\/\/# #\/\/\/\# ######### ``` is ``` \/ /\ ``` (`gcd(7, 5) = 1`, size of pattern is `2 x 2`) And the repeating pattern for `22 6` ``` ######################## #\ /\ /\ /\ /\ /\ # # \/ \/ \/ \/ \/ \# # /\ /\ /\ /\ /\ /# #/ \/ \/ \/ \/ \/ # #\ /\ /\ /\ /\ /\ # # \/ \/ \/ \/ \/ \# ######################## ``` is ``` \ / \/ /\ / \ ``` (`gcd(22, 6) = 2`, size of pattern is `4 x 4`) My solution does the following thing for each of the lines: it simply generates one line of the pattern, repeats it a few times and cut's it at the end so that it fit's into the box. ``` K\#+2QK implicit: Q is the second input number (=width) K K = \#+2Q "#" * (2 + Q) K print K (first line) Vvzp<QXXdyivzQN\\_hN\/Q\#\#)K implicit: vz is the first input number (=height) VQ for N in [0, 1, ..., vz-1]: ivzQ gcd(vz,Q) y 2gcd(vz,Q) d string with 2gcd(vz,Q) space chars X N\\ replace the Nth char with \ X _hN\/ replace the -(N+1)th char with / Q repeat Q times < Q only use the first Q chars p \#\# print "#" + ... + "#" ) end for K print K ``` [Answer] # C, 256 bytes ``` f(w,h){int i,j,x=1,y=1,v=1,u=1;char b[h+2][w+3];for(i=0;i<w+3;i++)for(j=0;j<h+2;j++)b[j][i]=!i\|\|!j\|\|i>w\|\|j>h?i>w+1?0:35:32;while((x\|\|y)&&(x<=w\|\|y<=h))v=x&&w+1-x?v:(x-=v,-v),u=y&&h+1-y?u:(y-=u,-u),b[y][x]=v/u<0?47:92,x+=v,y+=u;for(i=0;i<h+2;i++)puts(b[i]);} ``` I can probably get this under 200, and I'll add an explanation later, but I might have a paper due in a few hours I should be doing instead. [Answer] # J, 85 bytes Let `g = gcd(w,h)`. The function fills the elements of a `w/g by h/g` matrix with `g by g` tiles, having `/`'s and `\`'s in their diagonal and anti-diagonal. The resulting 4D array is raveled into a 2D one (the inside of the box) then surrounded with `#`'s. (The numbers `0 1 2 3` are used instead of `[space] / \ #` and the numbers are changed to characters at the end.) A direct position based computation of inside coordinate could maybe yield a bit shorter solution. ``` ' \/#'echo@:{~3,.~3,.3,~3,,$[:,[:,"%.0 2 1 3\|:((,:2\|.)@=@i.@+.){~[:(2&\|@+/&:i.)/,%+. ``` Usage: ``` 6 (' \/#'echo@:{~3,.~3,.3,~3,,$[:,[:,"%.0 2 1 3\|:((,:2\|.)@=@i.@+.){~[:(2&\|@+/&:i.)/,%+.) 22 ######################## #\ /\ /\ /\ /\ /\ # # \/ \/ \/ \/ \/ \# # /\ /\ /\ /\ /\ /# #/ \/ \/ \/ \/ \/ # #\ /\ /\ /\ /\ /\ # # \/ \/ \/ \/ \/ \# ######################## ``` [Try it online here.](http://tryj.tk/) [Answer] # Desmos Calculator - Non Competing to Help Further Knowledge [Try it online!](https://www.desmos.com/calculator/yddawvokl0) Inputs: ``` h as height of box, with 0-indexing w as width of box, with 0-indexing ``` Intermediates: ``` Let b = gcd(h,w), Let c = \|b-h%2b\| Or \|b-mod(h,2b)\| ``` * gcd(h,w) represents the [greatest common denominator](https://en.wikipedia.org/wiki/Greatest_common_divisor) * A % B, as in Javascript, or mod(A,B), as in Fortran, represents the [modulus operation](https://en.wikipedia.org/wiki/Modulo_operation), on the interval [0,B). Formula, abbreviated: ``` (\|b-(x+y)%2b\|-c)(\|b-(x-y)%2b\|-c)=0 ``` Outputs: ``` x as x position, 0-indexed, where the ball will land when released y as y position, 0-indexed, where the ball will land when released ``` How it Works: ``` (\|b-(x+y)%2b\|-c)(\|b-(x-y)%2b\|-c)=0 ^ OR operation - \|b-(x+y)%2b\|-c=0 or \|b-(x-y)%2b\|-c=0 \|b-(x+/-y)%2b\|-c = 0 \|b-(x+/-y)%2b\| = c \|b-(x+/-y)%2b\| = c means (b-(x+/-y))%2b = + or -c b-(x+/-y)%2b = +/- c -> b +/- c = (x+/-y)%2b -> (x+/-y) = n2*b + b +/- c Where n is integer. This will force patterns to repeat every 2b steps in x and y. Initial pattern n=0: (x +/- y) = b +/- c -> y = +/- x + b +/- c In the x positive and y positive plane only, these correspond to lines of positive and negative slope, set at intercept b, offset by c on either side. ``` Program fails to meet final criterion - generating ASCII art of box and lines, so I'm submitting as non-competitive for information to help others complete the challenge. Note that to get Desmos to work when c = 0 or c=b, a small offset factor of 0.01 was introduced, as Desmos seems to have bounds of Mod(A,B) of (0,B) instead of [0,B) ]
[Question] [ # Heatmaps Consider a rectangular room, on whose ceiling we have a thermal camera pointing downward. In the room, there are some number of heat sources of intensity `1-9`, the background temperature being `0`. The heat dissipates from each source, dropping by one unit per (non-diagonal) step. For example, the `20x10` room ``` ...........1........ .................... ...8................ ..5...............2. .................... .1.................. ................1... .................65. .................... ............2....... ``` contains 9 heat sources, and the temperature gradient shown by the thermal camera is ``` 34565432100100000000 45676543210000000000 56787654321000000110 45676543210000001221 34565432100000012321 23454321000000123432 12343210000001234543 01232100000012345654 00121000000011234543 00010000000121123432 ``` In graphical form this might look like: ![heatmap of 9 sources](https://i.stack.imgur.com/4RKN1.png) From the gradient, we can infer the positions and intensities of some heat sources, but not all. For example, all `9`s can always be inferred, since they have the maximal temperature, and so can the `8` in this case, since it produces a local maximum in the gradient. The `2` near the right border can also be inferred, even though it is not at a local maximum, since it does not have another `2` as a neighbor. The `5`s, on the other hand, are not inferred, since their heat might as well be produced by the more intense sources near them. The `0`s are known to contain no heat sources, but all the other tiles may potentially contain one. Let's denote the uncertain tiles by hyphens `-`, certain heat sources by the corresponding digits, and certain empty space by periods `.`: ``` ---------..1........ ----------.......... ---8-------......--. ----------......--2- ---------......----- --------......------ -------......------- .-----......-----6-- ..---.......-------- ...-.......-2------- ``` Your task shall be to produce this inferred pattern from the temperature gradient. # Rules You are given the input as a string delimited by either newlines or vertical pipes `\|`, whichever is more convenient, and the output shall be of the same form. There may be a trailing delimiter in the input and/or output, but no preceding one. The size of the input may vary, but its width and height are always at least `4`. Both functions and full programs are acceptable. The lowest byte count wins, and standard loopholes are forbidden. # Additional Test Cases Input: ``` 898778765432100 787667654321100 677656543211210 678765432112321 567654321123210 ``` which looks like this in graphical form: ![test case 1](https://i.stack.imgur.com/COXcj.png) Output: ``` -9---8-------.. -------------.. --------------. --8---------3-- -----------3--. ``` Input: ``` 7898 8787 7676 6565 ``` Output: ``` --9- 8--- ---- ---- ``` Input: ``` 00001 00000 00000 10000 ``` Output: ``` ....1 ..... ..... 1.... ``` [Answer] # CJam, ~~73 69 62~~ 55 bytes UPDATE : New algorithm. Shorter and more scope for improvement ``` qN/5ff{{[{_@_@<{I'0t}\}]W%}%z}4fI{):X-'-X~X'.??}f%N ``` How it works The logic is similar to the algorithm below, but here I am not checking for all 4 neighbors in a single iteration. Instead, I use a smaller approach to iterate through all rows and columns in both directions. Here are the steps involved: * Convert each character into sets of 5. The first 4 will be modified to tell if they are bigger than the adjacent cell in the row while iterating. Last one is for comparison purposes. * Iterate on each row and reduce on each row. While reducing, I have two 5 character string. I know what kind of iteration is [0 for rows normal, 1 columns reversed, 2 for rows reversed and 3 for columns normal] I update the ith character in the first 5 character string and make it 0 if it is smaller than the second. * After all 4 iterations, if all 5 characters are same and non-zero, that is the local maxima. I map through all 5 characters strings and convert them to either single digit, `.` or `-`. Here is an example run on a small input: ``` 7898 8787 7676 6565 ``` After first step: ``` ["77777" "88888" "99999" "88888" "88888" "77777" "88888" "77777" "77777" "66666" "77777" "66666" "66666" "55555" "66666" "55555"] ``` After second step: ``` ["00777" "08888" "99999" "88088" "88888" "07007" "88808" "77007" "77707" "06006" "77707" "66006" "66606" "05005" "66606" "55005"] ``` After last mapping to single character, final output: ``` --9- 8--- ---- ---- ``` Code Explanation: ``` qN/5ff* "Split the input on new line and convert each character"; "to string of 5 of those characters."; {{[{ }]W%}%z}4fI "This code block runs 4 times. In each iteration, it"; "maps over each row/column and then for each of them,"; "It reduce over all elements of the row/column"; "Using combination of W% and z ensures that both rows and"; "columns are covered and in both directions while reducing"; _@_@ "Take a copy of last two elements while reducing over"; < "If the last element is bigger than second last:"; {I'0t}\ "Convert the Ith character of the 5 char string of" "second last element to 0"; "We don't have to compare Ith character of last two 5 char"; "string as the smaller one will be having more leading"; "0 anyways. This saves 4 bytes while comparing elements"; {):X-'-X~X'.??}f%N* "This part of code converts the 5 char back to single char"; ):X "Remove the last character and store in X. This last char"; "was not touched in the prev. loop, so is the original char"; - "Subtract X from remaining 4 char. If string is not empty"; "then it means that it was not all same characters"; "In other words, this character was smaller then neighbors"; '- ? "If non-empty, then replace with - else ..."; X~X'.? "if int(X) is zero, put . else put X"; f%N* "The mapping code block was run for each row and then"; "The rows are joined by newline."; ``` [Try it here](http://cjam.aditsu.net/#code=qN%2F5ff%7B%7B%5B%7B_%40_%40%3C%7BI'0t%7D%5C%7D%5DW%25%7D%25z%7D4fI%7B)%3AX-'-X~X'.%3F%3F%7Df%25N&input=34565432100100000000%0A45676543210000000000%0A56787654321000000110%0A45676543210000001221%0A34565432100000012321%0A23454321000000123432%0A12343210000001234543%0A01232100000012345654%0A00121000000011234543%0A00010000000121123432) --- Older approach ``` qN/~_,):L0s]0s:Q_,{QI=:A[W1LL~)]If+Qf=$W=<'-A?A~\'.?I\t}fIL/W<Wf<N* ``` How it works The logic is simple, iterate through the grid and see if the current value is greater or equal to the remaining four neighbors - up, down, left and right. Then transform the current value based on the above rule and if the value is equal to 0, make it "." . Code Explanation ``` qN/~_,):L0s]0s:Q "This part of code pads the grid with 0s"; qN/~ "Read the input, split on new lines and unwrap the arrays"; _,):L "Copy the last row, taken length, increment and store in L"; 0s* "Get L length 0 string"; ]0s* "Wrap everything in an array and join the rows by 0"; :Q "Store this final single string in Q"; _,{ ... }fI "Copy Q and take length. For I in 0..length, execute block"; QI=:A "Get the I'th element from Q and store in A"; [WiLL~)]If+ "This creates indexes of all 4 neighboring cells to the Ith cell"; Qf= "Get all 4 values on the above 4 indexes"; $W= "Sort and get the maximum value"; <'-A? "If the current value is not the largest, convert it to -"; A~\'.? "If current value is 0, convert it to ."; I\t "Update the current value back in the string"; { ... }fIL/ "After the loop, split the resulting string into chunks of L"; W<Wf< "Remove last row and last column"; N* "Join by new line and auto print"; ``` [Try it online here](http://cjam.aditsu.net/#code=qN%2F~_%2C)%3AL0s%5D0s%3AQ_%2C%7BQI%3D%3AA%5BW1LL~)%5DIf%2BQf%3D%24W%3D%3C'-A%3FA~%5C'.%3FI%5Ct%7DfIL%2FW%3CWf%3CN&input=34565432100100000000%0A45676543210000000000%0A56787654321000000110%0A45676543210000001221%0A34565432100000012321%0A23454321000000123432%0A12343210000001234543%0A01232100000012345654%0A00121000000011234543%0A00010000000121123432) [Answer] # JavaScript (ES6) 99 ``` F=h=>[...h].map((c,i)=>[o=~h.search('\n'),-o,1,-1].some(d=>h[d+i]>c)&c>0?'-':c=='0'?'.':c).join('') ``` Test* In Firefox/FireBug console ``` console.log(F('\ 34565432100100000000\n\ 45676543210000000000\n\ 56787654321000000110\n\ 45676543210000001221\n\ 34565432100000012321\n\ 23454321000000123432\n\ 12343210000001234543\n\ 01232100000012345654\n\ 00121000000011234543\n\ 00010000000121123432\n'),'\n\n', F('\ 898778765432100\n\ 787667654321100\n\ 677656543211210\n\ 678765432112321\n\ 567654321123210\n'), '\n\n', F('7898\n8787\n7676\n6565\n')) ``` Output ``` ---------..1........ ----------.......... ---8-------......--. ----------......--2- ---------......----- --------......------ -------......------- .-----......-----6-- ..---.......-------- ...-.......-2------- -9---8-------.. -------------.. --------------. --8---------3-- -----------3--. --9- 8--- ---- ---- ``` [Answer] # Python 2: 154 byte ``` b=input() l=b.index('\n')+1 print''.join(('\n.'+('-'+v)[all([v>=b[j]for j in i-l,i-1,i+l,i+1if 0<=j<len(b)])])[('\n0'+v).index(v)]for i,v in enumerate(b)) ``` Input has to be of the form `"00001\n00000\n00000\n10000"`. Converting a string to a 2D-matrix is quite lengthy in Python. So I keep the original string format. I enumerate over the input, `i` is the index, `v` is the char (Finally enumerate saved bytes in a golf solution!!). For each pair `(i,v)` I compute the correct char of output, and join them. How do I choose the correct output char? If `v == '\n'`, the output char is `\n`, it `v == '0'`, than the output char is `'.'`. Otherwise I test the 4 neighbors of `v`, which are `b[i-b.index('\n')-1]` (above), `b[i-1]` (left, `b[i+1]` (right) and `b[i+b.index('\n')+1]` (under), if they are `<= v` and choose the char `'-'` or `v`. Here I'm comparing chars not the numbers, but it works quite fine, because the ascii values are in the correct order. Also there are no problems, if `b[i-1]` or `b[i+1]` equal `'\n'`, because `ord('\n') = 10`. # Pyth: ~~61~~ 58 ``` JhxQbVQK@QN~k@++b\.?\-f&&gT0<TlQ<K@QT[tNhN-NJ+NJ)Kx+b\0K)k ``` More or less a translation of the Python script. Quite ugly ;-) Try it online: [Pyth Compiler/Executor](https://pyth.herokuapp.com/) Same input format as the Python solution. ``` JhxQb Q = input() xQb Q.index('\n') h +1 J store in J VQK@QN~k.....)k k is initialized as empty string VQ ) for N in [0, 1, 2, ..., len(Q)-1]: K@QN K = Q[n] ~k k += ... (a char, computed in the next paragraph) ) end for k print k @...x+b\0K ... is a char of len 3 (is constructed below) +b\0 the string "\n0" x K find Q[d] in this string and return index, if not found -1 @... lookup in string at the computed position (this is done mod 3 automatically!) ++b\.?\-f&&gT0<TlQ<K@QT[tNhN-NJ+NJ)K not to the string [tNhN-NJ+NJ) the list [d-1, d+1, d-J, d+j] f filter the list for indices T which gT0 T >= 0 & and <TlQ T < len(Q) & and <K@QT Q[d] < Q[T] ?\- K use "-" if len(filter) > 0 else Q[d] this creates the third char ++b\. "\n" + "." + third char ``` [Answer] # Perl, ~~77, 75, 72~~ 70 Standard 2d regex matching tricks. ``` #!perl -p0 / /;$x="(.{@-})?";y/0/./while s/$.$x\K$"\|$"(?=$x$.)/-/s\|\|($"=$.++)<9 ``` Example: ``` $ perl heat.pl <in.txt ---------..1........ ----------.......... ---8-------......--. ----------......--2- ---------......----- --------......------ -------......------- .-----......-----6-- ..---.......-------- ...-.......-2------- ``` Try it [here](https://ideone.com/XQdGdR) [Answer] # Java, ~~307~~, ~~304~~, ~~303~~, ~~299~~ 298 This is for sure a "perfect" challenge for some Java codegolf :) ``` class M{public static void main(String[]a){int c=a[0].indexOf('\|'),i=c,d,v;char[]r=a[0].replace("\|","").toCharArray(),m=new char[(v=r.length+c)+c];for(;i<v;){m[i]=r[i++-c];}for(i=c;i<v;i++){a[0]=i%c<1?"\n":"";d=m[i];System.out.print(a[0]+(d<49?'.':m[i-c]>d\|m[i+c]>d\|m[i-1]>d\|m[i+1]>d?'-':m[i]));}}} ``` Input (pipe '\|' method): ``` 34565432100100000000\|45676543210000000000\|56787654321000000110\|45676543210000001221\|34565432100000012321\|23454321000000123432\|12343210000001234543\|01232100000012345654\|00121000000011234543\|00010000000121123432 ``` Output: ``` ---------..1........ ----------.......... ---8-------......--. ----------......--2- ---------......----- --------......------ -------......------- .-----......-----6-- ..---.......-------- ...-.......-2------- ``` [Answer] # APL, 92 ``` ('.-',⎕D)[1+(M≠0)+M{(1+⍺)×0≠⍺∧M[J/⍨Z∊⍨J←⍵∘+¨(⌽¨,+)(-,+)⊂0 1]∧.≤⍺}¨Z←⍳⍴M←↑{×⍴⍵:(⊂⍎¨⍵),∇⍞⋄⍬}⍞] ``` Example: ``` ('.-',⎕D)[1+(M≠0)+M{(1+⍺)×0≠⍺∧M[J/⍨Z∊⍨J←⍵∘+¨(⌽¨,+)(-,+)⊂0 1]∧.≤⍺}¨Z←⍳⍴M←↑{×⍴⍵:(⊂⍎¨⍵),∇⍞⋄⍬}⍞] 34565432100100000000 45676543210000000000 56787654321000000110 45676543210000001221 34565432100000012321 23454321000000123432 12343210000001234543 01232100000012345654 00121000000011234543 00010000000121123432 ---------..1........ ----------.......... ---8-------......--. ----------......--2- ---------......----- --------......------ -------......------- .-----......-----6-- ..---.......-------- ...-.......-2------- ``` [Answer] # Ruby 140 ``` f=->s{ r=s.dup l=s.index(?\n)+1 (0...s.size).map{\|i\| s[i]<?0\|\|r[i]=r[i]<?1??.:[i-1,i+1,i-l,i+l].map{\|n\|n<0??0:s[n]\|\|?0}.max>r[i]??-:s[i]} r} ``` Nothing special; just iterate through the map and compare the current value with the value of the four neighbors. Run it online with tests: <http://ideone.com/AQkOSY> [Answer] # R, 223 About the best I can come up with at the moment. Dealing with the string is quite expensive. I think there is room for improvement, but can't see it at the moment ``` s=strsplit;a=c(m<-do.call(rbind,s(s(scan(w="c"),'\|',T)[[1]],'')));w=(d<-dim(m))[1];n=c(-1,1,-w,w);cat(t(array(sapply(seq(a),function(x)if(a[x]>0)if(any(a[(n+x)[which(n+x>0)]]>a[x]))'-'else a[x]else'.'),d)),fill=d[2],sep='') ``` Test Result ``` > s=strsplit;a=c(m<-do.call(rbind,s(s(scan(w="c"),'\|',T)[[1]],'')));w=(d<-dim(m))[1];n=c(-1,1,-w,w);cat(t(array(sapply(seq(a),function(x)if(a[x]>0)if(any(a[(n+x)[which(n+x>0)]]>a[x]))'-'else a[x]else'.'),d)),fill=d[2],sep='') 1: 898778765432100\|787667654321100\|677656543211210\|678765432112321\|567654321123210 2: Read 1 item -9---8-------.. -------------.. --------------. --8---------3-- -----------3--. > s=strsplit;a=c(m<-do.call(rbind,s(s(scan(w="c"),'\|',T)[[1]],'')));w=(d<-dim(m))[1];n=c(-1,1,-w,w);cat(t(array(sapply(seq(a),function(x)if(a[x]>0)if(any(a[(n+x)[which(n+x>0)]]>a[x]))'-'else a[x]else'.'),d)),fill=d[2],sep='') 1: 34565432100100000000\|45676543210000000000\|56787654321000000110\|45676543210000001221\|34565432100000012321\|23454321000000123432\|12343210000001234543\|01232100000012345654\|00121000000011234543\|00010000000121123432 2: Read 1 item ---------..1........ ----------.......... ---8-------......--. ----------......--2- ---------......----- --------......------ -------......------- .-----......-----6-- ..---.......-------- ...-.......-2------- > ``` [Answer] ## J - 69 bytes ``` [:u:45+[:(+2 0 3{~"#1+)@((]]=(0,(,-)1 0,:0 1)>./@:\|.])-0=])"."0;._2 ``` Examples: ``` ([:u:45+[:(+2 0 3{~"#1+)@((]]=(0,(,-)1 0,:0 1)>./@:\|.])-0=])"."0;._2) (0 : 0) 34565432100100000000 45676543210000000000 56787654321000000110 45676543210000001221 34565432100000012321 23454321000000123432 12343210000001234543 01232100000012345654 00121000000011234543 00010000000121123432 ) ---------..1........ ----------.......... ---8-------......--. ----------......--2- ---------......----- --------......------ -------......------- .-----......-----6-- ..---.......-------- ...-.......-2------- ([:u:45+[:(+2 0 3{~"#1+)@((]]=(0,(,-)1 0,:0 1)>./@:\|.])-0=])"."0;._2) (0 : 0) 898778765432100 787667654321100 677656543211210 678765432112321 567654321123210 ) -9---8-------.. -------------.. --------------. --8---------3-- -----------3--. ``` PS: the `(0 : 0)` is the standard J way of specifying strings. You might as well use `\|` delimited strings (with a trailing `\|`). [Answer] # Excel VBA - 426 It'll be a rare occasion that VBA wins any code golf games, but as it's what I use the most, it's fun to play around with it. The first line is an edge case that made this longer than it seems it should have to be. ``` Sub m(a) b = InStr(a, "\|") For i = 1 To Len(a) t = Mid(a, i, 1) Select Case t Case "\|" r = r & "\|" Case 0 r = r & "." Case Else On Error Resume Next x = Mid(a, i - 1, 1) y = Mid(a, i + 1, 1) Z = Mid(a, i + b, 1) If i < b Then If t < x Or t < y Or t < Z Then r = r & "-" Else r = r & t End If Else If t < x Or t < y Or t < Z Or t < Mid(a, i - b, 1) Then r = r & "-" Else r = r & t End If End If End Select Next MsgBox r End Sub ``` The count doesn't include initial line whitespace. I played around with the idea of sending the input to a sheet and working from there, but I think looping the passed string character-by-character saves code. Call from Immediate Window: ``` m "34565432100100000000\|45676543210000000000\|56787654321000000110\|45676543210000001221\|34565432100000012321\|23454321000000123432\|12343210000001234543\|01232100000012345654\|00121000000011234543\|00010000000121123432" ``` Output (in a Window): ``` ---------..1........\|----------..........\|---8-------......--.\|----------......--2-\|---------......-----\|--------......------\|-------......-------\|.-----......-----6--\|..---.......--------\|...-.......-2------- ``` [Answer] ## Perl - 226 ``` sub f{for(split' ',$_[0]){chomp;push@r,r($_);}for(t(@r)){push@y,r($_)=~s/0/./gr}$,=$/;say t(@y);}sub r{$_[0]=~s/(?<=(.))?(.)(?=(.))?/$1<=$2&&$3<=$2?$2:$2eq'0'?0:"-"/ger;}sub t{@q=();for(@_){for(split//){$q[$i++].=$_;}$i=0;}@q} ``` You can try it on [ideone](https://ideone.com/feK1Uc). If anyone is interested in an explanation, let me know. [Answer] # Haskell - 193 ``` z='0' r=repeat z g s=zipWith3(\u t d->zip3(zip(z:t)u)t$zip(tail t++[z])d)(r:s)s$tail s++[r] f=unlines.map(map(\((l,u),t,(r,d))->case()of _\|t==z->'.'\|maximum[u,l,t,r,d]==t->t\|0<1->'-')).g.lines ``` `f` is a funtion that takes a string in the form `0001\n0000\n0000\n1000` and returns the required string. `g` is a function that takes a list of lists of chars and returns a list of lists of ((left, up), this, (right, down)). ]
[Question] [ The [Hilbert curve](http://en.wikipedia.org/wiki/Hilbert_curve) is a space filling fractal that can be represented as a [Lindenmayer system](http://en.wikipedia.org/wiki/L-system) with successive generations that look like this: ![Hilbert curve](https://i.stack.imgur.com/tAkQT.png) Thanks to <http://www.texample.net/tikz/examples/hilbert-curve/> for the image. # Goal Write the shortest program possible (in bytes) that takes a positive integer n from stdin and draws the nth order Hilbert curve to stdout using only forward slash, backward slash, space, and newline. For example, if the input is `1` the output must be ``` \ \/ ``` If the input is `2` the output must be ``` / \/\ /\ \ / /\/ \ \ \/ ``` If the input is `3` the output must be ``` \ /\/ / /\ \/\ \ \ /\ / / / / / \/ \/\ \ \/\ /\ \ \/ / / / /\/ /\/ / \ \ \ \/\ \/ \/\ \ / /\/ \ \ \/ ``` And so on. (They look nicer if you paste them into something with less line spacing.) The output should not contain newlines above or below the extremities of the curve, nor any trailing spaces on any lines. [Answer] ## Python, 282 ``` from numpy import* def r(n): x=2*n-2;b=3x/2+1;c=x/2+1;a=zeros((x2+2,)2,int);a[x+1,x+1]=1;a[b,x/2]=a[x/2,b]=-1 if n>1:s=r(n-1);a[:x,c:b]=rot90(s,3)-1;a[c:b,:x]\|=rot90(s)-1;a[c:b,x+2:]\|=s;a[x+2:,c:b]\|=s return a for l in r(input()):print''.join(' /\\'[c] for c in l).rstrip() ``` This uses a recursive approach to construct the nth order Hilbert curve out of the previous curve. The curves are represented as a 2d numpy array for better slicing and manipulation. Here are some examples: ``` $ python hilbert.py 2 / \/\ /\ \ / /\/ \ \ \/ $ python hilbert.py 3 \ /\/ / /\ \/\ \ \ /\ / / / / / \/ \/\ \ \/\ /\ \ \/ / / / /\/ /\/ / \ \ \ \/\ \/ \/\ \ / /\/ \ \ \/ $ python hilbert.py 4 / \/\ /\ \ / / /\/ \ \ \ /\ /\/ \/ \ \ / /\ /\/ / \/\ \ \ \ \/\ /\ / / \ \/\ \ / / \/ /\/ / /\/ \ \/\ / /\/ / /\ /\/ / \/\ \ \/\ \ \ / /\/ /\ / / /\ / / / \/\ \ / / \/ / / \/ \/\ /\ \ \ \ \/\ \ \/\ /\ \ / /\/ \/ / /\/ / / / /\/ \ \ /\ /\/ \ /\/ / \ \ \/ \ \ \ /\/ \ \/\ \/ /\/ / / / /\ \/\ \ \ \/ \/\ \ \ / /\/ \/\ /\ / / / \ \ / / / \/ \/\ \/ \ \ \/\ /\ \ \/ / / / /\/ /\/ / \ \ \ \/\ \/ \/\ \ / /\/ \ \ \/ ``` [Answer] ### Ruby, 247 230 205 characters ``` r=?D y=d=0 z=(1..2x=2gets.to_i.times{r.gsub!(/\w/){$&<?H?'-H~+D~D+~H-':'+D~-H~H-~D+'}}-1).map{' '2x} r.bytes{\|c\|c>99?(z[y-=s=-~d/2%2][x-=1-d/2]='/\\'[d%2] x+=d/2 y+=1-s):d-=c d%=4} puts z.map &:rstrip ``` An ASCII-turtle approach using the Lindenmayer representation (try [here](http://ideone.com/5woYsD)). Big thank you to [@Ventero](https://codegolf.stackexchange.com/users/84/ventero) for some more golfing. [Answer] # Malsys - 234 221 characters I smell some L-systems here :) Malsys is online L-system interpreter. This is not really serious entry but I felt like this solution is somewhat interesting. Syntax of Malsys is not really good for golfing since it contains a lot of lengthy keywords but still, it's quite short, readable, and expressive. ``` lsystem HilbertCurveAscii { set symbols axiom = R; set iterations = 5; set rightAngleSlashMode = true; interpret F as DrawLine; interpret + as TurnLeft; interpret - as TurnRight; rewrite L to + R F - L F L - F R +; rewrite R to - L F + R F R + F L -; } process all with HexAsciiRenderer; ``` <http://malsys.cz/g/3DcVFMWn> Interpreter: <http://malsys.cz/Process> Golfed version: ``` lsystem H{set symbols axiom=R;set iterations=3;set rightAngleSlashMode=1;interpret.as DrawLine;interpret+as TurnLeft;interpret-as TurnRight;rewrite L to+R.-L.L-.R+;rewrite R to-L.+R.R+.L-;}process H with HexAsciiRenderer; ``` And how about Ascii hexagonal Gosper curve? :) ``` ____ ____ \__ \ \__ \__/ / __ __/ ____ \ \ \ / __ \__ \ \/ \ \ \__/ / __ \/ ____ \/ / \__ \__/ __/ ``` <http://malsys.cz/g/ae5v5vGB> [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 90 bytes[SBCS](https://github.com/abrudz/SBCS) ``` ⎕∘←¨' +$'⎕r''¨↓1↓∘⍉∘⌽⍣4⊢' /\'[{3\|(⊢+⍉)2@(¯1 0+3 1×s÷2)s⊢(¯.5×≢⍵)⊖(2×s←⍴⍵)↑⍵,⍨-⊖⍵}⍣⎕⊢2 2⍴0] ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qZv6jtgkGXI862tNA3EcdM4D8QyvUFbRV1IH8InX1QysetU02BGKQXG8niOzZ@6h3scmjrkXqCvox6tHVxjUaQI42UFbTyEHj0HpDBQNtYwXDw9OLD2830iwGygEF9UwPT3/UuehR71bNR13TNIyAskCrHvVuAYu0TQRSOo96V@gCJYHMWqANIPd0LTJSMAIqMoj9D3Tj/zQuQ640LiMgNgYA "APL (Dyalog Unicode) – Try It Online") `2 2⍴0` a 2x2 matrix of zeroes `{ }⍣⎕` input N and apply a function N times `⍵,⍨-⊖⍵` concatenate to the left of the matrix a vertically reversed and negated copy of itself `(2×s←⍴⍵)↑` pad with zeroes so that the dimensions (remembered as `s`) are twice the argument's `¯.5×≢⍵` rotate down in order to centre it vertically, sandwiched between the padding zeroes `2@(¯1 0+3 1×s÷2)` put 2-s at specific locations - these are the linking slashes between smaller instances of the fractal `(⊢+⍉)` add the matrix with its transposed self `3\|` modulo 3; we used negation, so please note that -1≡2 (mod 3) and -2≡1 (mod 3) `' /\'[ ]` use the matrix elements as indices in the string `' /\'` `1↓∘⍉∘⌽⍣4` trim the 1-element-wide empty margin from all sides `↓` split into lines `' +$'⎕r''¨` remove trailing spaces from each (this challenge requires it) `⎕∘←¨` output each [Answer] # JavaScript (ES6) 313 ~~340~~ Edit* Some character removed using really bad practices - like global variable w instead of a return value from function H Converting x,y position to distance d (see [Wikipedia](http://en.wikipedia.org/wiki/Hilbert_curve)) for each x,y and verifying if the nearest positions are connected, Test in FireFox console. Input via popup, output via console.log. There are no trailing spaces and no newlines above or below the image. But each line is terminated with a newline, I think it's the correct way to make an Ascii art image. ``` n=1<<prompt(),d=n-1 H=(s,x,y)=>{for(w=0;s>>=1;)p=x&s,q=y&s,w+=ss(3!!p^!!q),q\|\|(p&&(x=s-1-x,y=s-1-y),[x,y]=[y,x])} for(r=t='';++r<d+n;t+='\n')for(r>d?(x=r-d,f=x-1):(f=d-r,x=0),t+=' '.repeat(f),z=r-x;x<=z;) h=H(n,y=r-x,x)\|w,H(n,y,x-1),x?t+=' \\'[h-w<2&w-h<2]:0,H(n,y-1,x++),y?t+=' /'[h-w<2&w-h<2]:0 console.log(t) ``` [Answer] # Perl, 270 Characters Super golfed ``` $_=A,%d=<A -BF+AFA+FB- B +AF-BFB-FA+>,$x=2($n=<>)-2;eval's/A\|B/$d{$&}/g;'x$n;s/A\|B//g;map{if(/F/){if($r+$p==3){$y+=$p<=>$r}else{$x+=$r<2?$r-$p:$p-$r}$s[($r-1)%4>1?$x--:$x++][$r>1?$y--:$y++]=qw(/ \\)[($p=$r)%2]}else{($r+=2/-/-1)%=4}}/./g;map{print map{$_\|\|$"}@$_,$/}@s ``` Not so much golfed ``` $_=A,%d=<A -BF+AFA+FB- B +AF-BFB-FA+>,$x=2*($n=<>)-2; eval's/A\|B/$d{$&}/g;'x$n; s/A\|B//g; map{if(/F/){ if($r+$p==3){$y+=$p<=>$r}else{$x+=$r<2?$r-$p:$p-$r} $s[($r-1)%4>1?$x--:$x++][$r>1?$y--:$y++]=qw(/ \\)[($p=$r)%2] }else{ ($r+=2/-/-1)%=4 } }/./g; map{print map{$_\|\|$"}@$_,$/}@s ``` Could probably golf it down more if I better understood Perl. Uses a Lindenmayer system approach using production rules defined in line 1. ]
[Question] [ # Programmin' Pac-Man ## Setting You play as Pac-Man. You want to collect pellets, fruit, and power pellets before anybody else, all while avoiding ghosts. ## Rules 1. Every valid Pac-Man will be in a single maze. The player with the highest cumulative score after 10 games will win. 2. A game is over when all Pac-Men are dead, all pellets are gone, or 500 turns have passed 3. If a Pac-Man dies, he continues to play as a ghost 4. Eating a Power pellet will make you invincible for 10 turns, and allows you to eat Ghosts 5. Eating a Ghost will teleport the ghost to a random location 6. Ghosts cannot eat anything except Pac-Men, and do not get any points 7. Eating the following items as Pac-Man will get you the following points: 7. Pellet: 10 8. Power Pellet: 50 9. Fruit: 100 10. Ghost: 200 ## The Maze If there are n Pac-Men, then a maze of size `sqrt(n)10` by `sqrt(n)10` will be generated using [Prim's algorithm](http://en.wikipedia.org/wiki/Prim%27s_algorithm) (due to it's low river factor), then braided completely, giving preference to already existing dead ends. Furthermore, this braiding can be done across the edges, so that there are a few pathways from top to bottom and from left to right. There will be: 1. `2n` Ghosts 2. `4n` Power Pellets 3. `2n` Fruit 4. `n` Pac-Men in spots where connected neighbors squares are empty. 5. All remaining empty spots will be filled with pellets Hence, an initial map with 10 players will look something like this (Ghosts = green, Pellets = aqua, fruit = red, Pac-Man = yellow): ![Maze](https://i.stack.imgur.com/WUTX1.png) ## Input/Output At the beginning of the game, You will be given a single line of characters, representing the walls in every square of the map. For each square, starting with the top left, moving right, and wrapping to the next line, you will be given a hex digit representing the wall situation: ``` 0: No walls 1: North wall 2: East wall 3: East & North wall 4: South wall 5: South & North wall 6: South & East wall 7: Won't occur 8: West wall 9: West & North wall A: West & East wall B: Won't occur C: West & South wall D: Won't occur E: Won't occur F: Won't occur ``` Put simply, North=1, East=2, South=4, and West=8, added together. Then, each turn, you will be given your current position and the items in your line of sight (if you are a Pac-Man. All ghosts receive all squares from -5 to +5 from their relative position). Your line of sight will be based on the direction you travelled last turn. If you travelled north, you will be given all squares directly North, East, and West of you until a wall cuts off your view plus a single square Northwest and Northeast, if no wall cuts off your view. If you choose not to move, you will be given the squares in all 8 directions. For the visual, `I` means invisible, `V` means visible, `P` means Pac-Man(assuming Pac-Man is facing north): ``` \|I I\|V\|I\| \|I V\|V V\| \|V V P\|I\| \|I I\|I\|I\| ``` Each square will be given by a coordinate, and then it's contents. It's contents are represented by the following characters: 1. `P`: 1 or more Pac-Man 2. `G`: 1 or more Ghosts 3. `o`: Pellet 4. `O`: Power pellet 5. `F`: Piece of Fruit 6. `X`: Nothing If there is a ghost and something else on a square, `G` will be returned. Hence, if you were on square `23,70`, you just moved north, the square above you is a dead end and contains a Power pellet, and you have walls on both sides of you, your input would be: ``` 23,70X 22,70O ``` On your current square, it will show a `G` if you are a Ghost, a `P` if there is another Pac-Man on your square, otherwise an `X` Then you will return the following items via STDOUT: A single character representing a direction (`N`orth, `E`ast, `S`outh, `W`est, or `X`Stay). Previous to passing in a direction, you may also pass in any coordinate as `x,y`, and the walls of that square will be passed back (as described above) The program must be continuously running until `Q` is passed to it via STDIN. Programs will be restarted for each game. Accessing other information outside of what is passed to STDIN (including other Pac-Men's data or the data held by the host program) is not allowed. Failure to return a move within 1000 ms will terminate the program (Running on my fairly decent Win8 machine). You will be given 2 seconds to process the initial maze layout when it is given Host will be written in Python, and code to test your bot is forthcoming. ## Exceptional cases * If multiple Pac-Men end up on the same location, neither get the contents of the current square, unless exactly 1 of them is invincible, in which case, the invincible Pac-Man will receive the pellet. * A Pac-Man eaten by a Ghost will not be teleported somewhere else. If two Pac-Men are on a square, and one is invincible, the ghost will be teleported. * Being teleported as a Ghost prevents you from moving for 1 turn. When playing as a Ghost, you simply will have your turn skipped * Attempting to move through a wall will be interpreted as "Stay" * Each of the initial ghosts will receive one of the 4 personality traits, as described [here](http://gameinternals.com/post/2072558330/understanding-pac-man-ghost-behavior), with the following modification: 1. The bugs described will not be duplicated 2. They will all be active from the beginning 3. They are vulnerable only to the player who ate the pellet 4. They will indefinitely switch from scatter to chase, each having a fixed number of turns before switch 5. Upon switching to chase, they will find the nearest Pac-Man to chase, and will chase that Pac-Man for the duration of their chase. (If there is a tie for closeness, the Pac-Man will be picked pseudorandomly) 6. Blinky won't speed up 7. Inky will pick the nearest ghost to base his calculations off of after switching to chase. 8. Clyde will find all players 8 squares away, then follow the furthest player. 9. All ghosts except Clyde won't target a player farther than 5 squares away I will accept compilable code from a standard language or an .exe (with accompanying code). ## Programming Tips You may with my controller. You need to put a /bots/your\_bot\_name/ folder in the same directory as the program. Within the folder, you need to add a command.txt containing a command to execute your program (ex: `python my_bot.py`), and the your bot. The controller code is on [Github](https://github.com/thenameipicked/Pacman) (Python code, requires Pygame if you want graphics.) Tested on windows and linux # SCORES > > ghostbuster: 72,840 points > > > pathy: 54,570 points > > > shortsighted: 50,820 points > > > avoidinteraction: 23,580 points > > > physicist: 18,330 points > > > randomwalk: 7,760 points > > > dumbpac: 4,880 points > > > [Answer] # GhostBuster - Python Picks a random spot on the map, uses A\* algorithm to find the best path forward. Once it reaches its destination, it will pick a new one and continue. It will try to avoid ghosts, but with the limited FOV, it will occasionally run into them. It will avoid walking on spots already visited. * Added logic for ghost. Picks a close (<8) random point and moves there, disregarding scores other than pacmen * Added invincibility logic * Adjusted point values of squares * Bug (if he is too good and eats all the pellets, the game freezes for some reason) Uses some code of Sparr's, thank you for the logic. --- Windows 7, Visual Studios with Python Tools. Should work on linux boxes. ``` #!/usr/bin/env python import os import re import sys import math import random sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0) # automatically flush stdout P,G,o,O,F,X = 5,600,-10,-100,-100,10 PreviousSquarePenalty = 10 # read in the maze description maze_desc = sys.stdin.readline().rstrip() mazeSize = int(math.sqrt(len(maze_desc))) North,East,South,West = range(4) DIRECTIONS = ['N','E','S','W'] Euclidian,Manhattan,Chebyshev = range(3) sign = lambda x: (1, -1)[x<0] wrap = lambda v : v % mazeSize class Node(object): def __init__(self, x, y, value): self.x, self.y = x,y self.wallValue = int(value, 16); #Base 16 self.nodes = {} self.item = 'o' # Start as normal pellet def connect(self, otherNode, dir): if dir not in self.nodes: self.nodes[dir] = otherNode otherNode.nodes[(dir+2)%4] = self def distance(self, otherNode, meth = Manhattan): xd = abs(otherNode.x - self.x) yd = abs(otherNode.y - self.y) xd = min(xd, mazeSize - xd) yd = min(yd, mazeSize - yd) if meth == Euclidian: return math.sqrt(xd * xd + yd * yd) if meth == Manhattan: return xd + yd if meth == Chebyshev: return max(xd, yd) def direction(self, otherNode): for key, value in self.nodes.iteritems(): if value == otherNode: return DIRECTIONS[key] return 'ERROR' def getScore(self): score = eval(self.item) for node in self.nodes.values(): score += eval(node.item) return score def nearbyGhost(self): if self.item == 'G': return True for node in self.nodes.values(): if node.item == 'G': return True return False def __hash__(self): return (391 + hash(self.x))23 + hash(self.y) def __eq__(self, other): return (self.x, self.y) == (other.x, other.y) def __ne__(self, other): return (self.x, self.y) != (other.x, other.y) def __str__(self): return str(self.x)+","+str(self.y) def __repr__(self): return str(self.x)+","+str(self.y) # Make all the nodes first nodes = {} i = 0 for y in range(mazeSize): for x in range(mazeSize): nodes[x,y] = Node(x,y,maze_desc[i]) i+=1 # Connect all the nodes together to form the maze for node in nodes.values(): walls = node.wallValue x,y = node.x,node.y if not walls&1: node.connect(nodes[x,wrap(y-1)], North) if not walls&2: node.connect(nodes[wrap(x+1),y], East) if not walls&4: node.connect(nodes[x,wrap(y+1)], South) if not walls&8: node.connect(nodes[wrap(x-1),y], West) toVisit = set(nodes.values()) currentNode = None destinationNode = None previousNode = None testInvincibilty = False invincibility = 0 isGhost = False turns = 0 def aStar(startNode, endNode): openSet = set([startNode]) closedSet = set() gScores = {startNode: 0} cameFrom = {} curNode = startNode while openSet: minF = 100000000 for node in openSet: g = gScores[node] h = node.distance(endNode) f = g+h if f < minF: minF = f curNode = node if curNode == endNode: path = [] while curNode != startNode: path.insert(0, curNode) curNode = cameFrom[curNode] return path openSet.remove(curNode) closedSet.add(curNode) for node in curNode.nodes.values(): if node in closedSet: continue g = gScores[curNode] if isGhost: g += 1 if node.item == 'P': g -= 10 # prefer PacMen else: s = node.getScore(); if invincibility > 1: g -= abs(s) # everything is tasty when invincible else: g += s if previousNode and node == previousNode: g += PreviousSquarePenalty # penalize previous square isBetter = False if node not in openSet: openSet.add(node) isBetter = True elif g < gScores[node]: isBetter = True if isBetter: gScores[node] = g cameFrom[node]=curNode # regex to parse a line of input input_re = re.compile('(?:([-\d]+),([-\d]+)([PGoOFX]?) ?)+') while True: info = sys.stdin.readline().rstrip() if (not info) or (info == "Q"): break turns += 1 # break a line of input up into a list of tuples (X,Y,contents) info = [input_re.match(item).groups() for item in info.split()] # update what we know about all the cells we can see for cell in info: nodes[int(cell[0]),int(cell[1])].item = cell[2] currentNode = nodes[int(info[0][0]),int(info[0][1])] if turns == 1: print 'X' continue if not isGhost and currentNode.item == 'G': isGhost = True destinationNode = random.sample(nodes.values(), 1)[0] if isGhost: while destinationNode == currentNode or currentNode.distance(destinationNode) > 8: destinationNode = random.sample(nodes.values(), 1)[0] else: if invincibility > 0: invincibility -= 1 if testInvincibilty: testInvincibilty = False if currentNode.item == 'X': invincibility += 10 while not destinationNode or destinationNode == currentNode: destinationNode = random.sample(toVisit, 1)[0] if currentNode.item == 'X': toVisit.discard(currentNode) bestPath = aStar(currentNode, destinationNode) nextNode = bestPath[0] direction = currentNode.direction(nextNode) if not isGhost and nextNode.item == 'O': testInvincibilty = True previousNode = currentNode print direction ``` [Answer] # shortsighted This pac avoids adjacent ghosts unless he can eat them, moves onto adjacent fruit or pellets, and walks at random as a last resort. ``` #!/usr/bin/env python import os import re import sys import math import random sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0) # automatically flush stdout # read in the maze description maze_desc = sys.stdin.readline().rstrip() maze_size = int(math.sqrt(len(maze_desc))) # turn the maze description into an array of arrays # [wall bitmask, item last seen in square] def chunks(l, n): for i in xrange(0, len(l), n): yield l[i:i+n] maze = [] for row in chunks(maze_desc, maze_size): maze.append([[int(c,16),'X'] for c in row]) # regex to parse a line of input input_re = re.compile('(?:([-\d]+),([-\d]+)([PGoOFX]?) ?)+') turn = 0 invincibility_over = 0 last_move = None while True: info = sys.stdin.readline().rstrip() if (not info) or (info == "Q"): break # break a line of input up into a list of tuples (X,Y,contents) info = info.split() info = [input_re.match(item).groups() for item in info] # update what we know about all the cells we can see for cell in info: maze[int(cell[1])][int(cell[0])][1] = cell[2] # current location x = int(info[0][0]) y = int(info[0][1]) # which directions can we move from our current location? valid_directions = [] # we might consider sitting still # valid_directions.append('X') walls = maze[y][x][0] if not walls&1: valid_directions.append('N') if not walls&2: valid_directions.append('E') if not walls&4: valid_directions.append('S') if not walls&8: valid_directions.append('W') # which direction has the highest value item? best_value = 0 best_direction = 'X' for c in [(x,y-1,'N'),(x+1,y,'E'),(x,y+1,'S'),(x-1,y,'W')]: if c[2] in valid_directions: # am I a ghost? if maze[y][x][1] == 'G': if maze[c[1]%maze_size][c[0]%maze_size][1] == "P": best_value = 999 best_direction = c[2] else: if maze[c[1]%maze_size][c[0]%maze_size][1] == 'F': if best_value < 100: best_value = 100 best_direction = c[2] elif maze[c[1]%maze_size][c[0]%maze_size][1] == 'O': if best_value < 50: best_value = 50 best_direction = c[2] elif maze[c[1]%maze_size][c[0]%maze_size][1] == 'o': if best_value < 10: best_value = 10 best_direction = c[2] elif maze[c[1]%maze_size][c[0]%maze_size][1] == 'G': if turn < invincibility_over: # eat a ghost! if best_value < 200: best_value = 200 best_direction = c[2] else: # avoid the ghost valid_directions.remove(c[2]) # don't turn around, wasteful and dangerous if last_move: reverse = ['N','E','S','W'][['S','W','N','E'].index(last_move)] if reverse in valid_directions: valid_directions.remove(reverse) if best_value == 50: invincibility_over = turn + 10 if best_direction != 'X': # move towards something worth points # sys.stderr.write("good\n") last_move = best_direction elif len(valid_directions)>0: # move at random, not into a wall # sys.stderr.write("valid\n") last_move = random.choice(valid_directions) else: # bad luck! # sys.stderr.write("bad\n") last_move = random.choice(['N','E','S','W']) print last_move turn += 1 ``` [Answer] # avoider Avoid all ghosts as a pacman, and all pacmen when a ghost. Tries to avoid any of its own kind if possible, and then avoids turning 180 if possible. ``` #!/usr/bin/env python import os import re import sys import math import random sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0) # automatically flush stdout # read in the maze description maze_desc = sys.stdin.readline().rstrip() maze_size = int(math.sqrt(len(maze_desc))) # turn the maze description into an array of arrays of numbers indicating wall positions def chunks(l, n): for i in xrange(0, len(l), n): yield l[i:i+n] maze = [] for row in chunks(maze_desc, maze_size): maze.append([[int(c,16),'X'] for c in row]) # regex to parse a line of input input_re = re.compile('(?:([-\d]+),([-\d]+)([PGoOFX]?) ?)+') last_moved = 'X' while True: info = sys.stdin.readline().rstrip() if (not info) or (info == "Q"): break # break a line of input up into a list of tuples (X,Y,contents) info = info.split() info = [input_re.match(item).groups() for item in info] # location x = int(info[0][0]) y = int(info[0][1]) # update what we know about all the cells we can see for cell in info: maze[int(cell[1])][int(cell[0])][1] = cell[2] # which directions can we move from our current location? valid_directions = [] walls = maze[y][x][0] if not walls&1: valid_directions.append('N') if not walls&2: valid_directions.append('E') if not walls&4: valid_directions.append('S') if not walls&8: valid_directions.append('W') bad_directions = [] for c in [(x,y-1,'N'),(x+1,y,'E'),(x,y+1,'S'),(x-1,y,'W')]: if c[2] in valid_directions: # am I a ghost? if maze[y][x][1] == 'G': # it's a pacman, run. interaction is always a risk. if maze[c[1]%maze_size][c[0]%maze_size][1] == "P": valid_directions.remove(c[2]) # another ghost? let me move away. elif maze[c[1]%maze_size][c[0]%maze_size][1] == "G": bad_directions.append(c[2]) else: # it's a ghost, run. ghosts are evil. if maze[c[1]%maze_size][c[0]%maze_size][1] == "G": valid_directions.remove(c[2]) # its another pacman, move away! elif maze[c[1]%maze_size][c[0]%maze_size][1] == "P": bad_directions.append(c[2]) # if possible to avoid normal contact, do so good_directions = list(set(valid_directions) - set(bad_directions)) if len(good_directions) > 0: valid_directions = good_directions # if not the only option, remove going backwards from valid directions if len(valid_directions) > 1: if last_moved == 'N' and 'S' in valid_directions: valid_directions.remove('S') elif last_moved == 'S' and 'N' in valid_directions: valid_directions.remove('N') elif last_moved == 'W' and 'E' in valid_directions: valid_directions.remove('E') elif 'W' in valid_directions: valid_directions.remove('W') # if possible, continue in the same direction if last_moved in valid_directions: print last_moved # prefer turning left/right randomly instead of turning 180 # backwards has been removed from valid_directions if not # the only option elif len(valid_directions) > 0: last_moved=random.choice(valid_directions) print last_moved # can't move, so stay put. desire to continue in original # direction remains. else: print 'X' ``` [Answer] # Physicist, Haskell The physicist Pac-Man believe that [Newton's law of universal gravitation](http://en.wikipedia.org/wiki/Newton's_law_of_universal_gravitation) can help him win the game. Then he just apply it to all other objects he know during the game. Since the physicist is old and has bad memory, he can only remember things in 5 rounds. Hooooly, the bad memory actually helps him to score better. This answer has two fille: `Main.hs`, contains the interesting part. * `Pacman.hs`, just some boring code the handle the protocol. You may use it to write your own haskell solution. It doesn't contain any AI code. Oh, wait, we have a `Makefile`, too. Here they comes: ## Main.hs ``` import Pacman import Data.Complex import Data.List import Data.Function import qualified Data.Map as Map import Data.Maybe import System.IO data DebugInfo = DebugInfo { debugGrid :: Grid , debugForce :: Force , debugAction :: Action } deriving (Show) data Physicist = Physicist [(Int, Object)] (Maybe DebugInfo) type Force = Complex Double calcForce :: Int -> Position -> PlayerType -> Object -> Force calcForce n p1 t1 object = if d2 == 0 then 0 else base / (fromIntegral d2 ** 1.5 :+ 0) where (x1, y1) = p1 (x2, y2) = p2 wrap d = minimumBy (compare `on` abs) [d, n - d] dx = wrap $ x2 - x1 dy = wrap $ y2 - y1 Object t2 p2 = object d2 = dx * dx + dy * dy base = (fromIntegral dx :+ fromIntegral dy) * case t1 of PacmanPlayer -> case t2 of Pellet -> 10.0 PowerPellet -> 200.0 Ghost -> -500.0 Pacman -> -20.0 Fruit -> 100.0 Empty -> -2.0 GhostPlayer -> case t2 of Pellet -> 10.0 PowerPellet -> 200.0 Ghost -> -50.0 Pacman -> 500.0 Fruit -> 100.0 Empty -> -2.0 instance PlayerAI Physicist where findAction player info = (action, player') where Player { playerType = type_ , playerField = field , playerMemory = Physicist objectsWithAge _ } = player n = fieldSize field NormalRound pos _ objects = info objectsWithAge' = combineObjects objectsWithAge objects objects' = map snd objectsWithAge' directionChoices = filter (not . gridHasWall grid) directions4 totalForce = sum $ map (calcForce n pos type_) objects' grid = fromMaybe (error $ "invalid position " ++ show pos) $ (fieldGetGrid field) pos action = if magnitude totalForce < 1e-10 then if null directionChoices then Stay else Move $ head directionChoices else Move $ maximumBy (compare `on` (projectForce totalForce)) directionChoices debugInfo = Just $ DebugInfo grid totalForce action player' = player { playerMemory = Physicist objectsWithAge' debugInfo } -- roundDebug player _ = do -- let Physicist objects debugInfo = playerMemory player -- type_ = playerType player -- hPrint stderr (objects, debugInfo) combineObjects :: [(Int, Object)] -> [Object] -> [(Int, Object)] combineObjects xs ys = Map.elems $ foldr foldFunc initMap ys where foldFunc object@(Object type_ pos) = Map.insert pos (0, object) addAge (age, object) = (age + 1, object) toItem (age, object@(Object _ pos)) = (pos, (age, object)) initMap = Map.fromList . map toItem . filter filterFunc . map addAge $ xs filterFunc (age, object@(Object type_ _)) \| type_ == Empty = True \| age < maxAge = True \| otherwise = False maxAge = 5 projectForce :: Force -> Direction -> Double projectForce (fx :+ fy) (Direction dx dy) = fx * fromIntegral dx + fy * fromIntegral dy main :: IO () main = runAI $ Physicist [] Nothing ``` ## Pacman.hs ``` module Pacman ( Field(..) , Grid(..) , Direction(..) , directions4, directions8 , Position , newPosition , Player(..) , PlayerType(..) , ObjectType(..) , Object(..) , RoundInfo(..) , Action(..) , runAI , PlayerAI(..) ) where import Data.Bits import Data.Char import Data.List import Data.Maybe import qualified Data.Map as Map import qualified System.IO as SysIO data Field = Field { fieldGetGrid :: Position -> Maybe Grid , fieldSize :: Int } data Grid = Grid { gridHasWall :: Direction -> Bool , gridPos :: Position } instance Show Grid where show g = "Grid " ++ show (gridPos g) ++ ' ':reverse [if gridHasWall g d then '1' else '0' \| d <- directions4] data Direction = Direction Int Int deriving (Show, Eq) directions4, directions8 :: [Direction] directions4 = map (uncurry Direction) [(-1, 0), (0, 1), (1, 0), (0, -1)] directions8 = map (uncurry Direction) $ filter (/=(0, 0)) [(dx, dy) \| dx <- [-1..1], dy <- [-1..1]] type Position = (Int, Int) newPosition :: (Int, Int) -> Position newPosition = id data Player a = Player { playerType :: PlayerType , playerField :: Field , playerRounds :: Int , playerMemory :: a } data PlayerType = PacmanPlayer \| GhostPlayer deriving (Show, Eq) class PlayerAI a where onGameStart :: a -> Field -> IO () onGameStart _ _ = return () onGameEnd :: a -> IO () onGameEnd _ = return () findAction :: Player a -> RoundInfo -> (Action, Player a) roundDebug :: Player a -> RoundInfo -> IO () roundDebug _ _ = return () data ObjectType = Pacman \| Ghost \| Fruit \| Pellet \| PowerPellet \| Empty deriving (Eq, Show) data Object = Object ObjectType Position deriving (Show) data RoundInfo = EndRound \| NormalRound Position PlayerType [Object] data Action = Stay \| Move Direction deriving (Show) parseField :: String -> Field parseField s = if validateField field then field else error $ "Invalid field: " ++ show ("n", n, "s", s, "fieldMap", fieldMap) where field = Field { fieldGetGrid = flip Map.lookup fieldMap , fieldSize = n } (n : _) = [x \| x <- [0..], x * x == length s] fieldMap = Map.fromList [ ((i, j), parseGrid c (newPosition (i, j))) \| (i, row) <- zip [0..n-1] rows, (j, c) <- zip [0..n-1] row ] rows = reverse . snd $ foldr rowFoldHelper (s, []) [1..n] rowFoldHelper _ (s, rows) = let (row, s') = splitAt n s in (s', row:rows) validateField :: Field -> Bool validateField field@(Field { fieldGetGrid=getGrid, fieldSize=n }) = all (validateGrid field) $ map (fromJust.getGrid) [(i, j) \| i <- [0..n-1], j <- [0..n-1]] validateGrid :: Field -> Grid -> Bool validateGrid field@(Field { fieldGetGrid=getGrid, fieldSize=n }) grid@(Grid { gridPos=pos }) = all (==True) [gridHasWall grid d == gridHasWall (getNeighbour d) (reverse d) \| d <- directions4] where reverse (Direction dx dy) = Direction (-dx) (-dy) (x, y) = pos getNeighbour (Direction dx dy) = fromJust . getGrid . newPosition $ (mod (x + dx) n, mod (y + dy) n) parseGrid :: Char -> Position -> Grid parseGrid c pos = Grid gridHasWall pos where walls = zip directions4 bits bits = [((x `shiftR` i) .&. 1) == 1 \| i <- [0..3]] Just x = elemIndex (toLower c) "0123456789abcdef" gridHasWall d = fromMaybe (error $ "No such direction " ++ show d) $ lookup d walls parseRoundInfo :: String -> RoundInfo parseRoundInfo s = if s == "Q" then EndRound else NormalRound pos playerType objects' where allObjects = map parseObject $ words s Object type1 pos : objects = allObjects objects' = if type1 `elem` [Empty, Ghost] then objects else allObjects playerType = case type1 of Ghost -> GhostPlayer _ -> PacmanPlayer parseObject :: String -> Object parseObject s = Object type_ (newPosition (x, y)) where (y, x) = read $ "(" ++ init s ++ ")" type_ = case last s of 'P' -> Pacman 'G' -> Ghost 'o' -> Pellet 'O' -> PowerPellet 'F' -> Fruit 'X' -> Empty c -> error $ "Unknown object type: " ++ [c] sendAction :: Action -> IO () sendAction a = putStrLn name >> SysIO.hFlush SysIO.stdout where name = (:[]) $ case a of Stay -> 'X' Move d -> fromMaybe (error $ "No such direction " ++ show d) $ lookup d $ zip directions4 "NESW" runPlayer :: PlayerAI a => Player a -> IO () runPlayer player = do roundInfo <- return . parseRoundInfo =<< getLine case roundInfo of EndRound -> return () info@(NormalRound _ type_' _) -> do let updateType :: Player a -> Player a updateType player = player { playerType = type_' } player' = updateType player (action, player'') = findAction player' info roundDebug player'' info sendAction action let updateRounds :: Player a -> Player a updateRounds player = player { playerRounds = playerRounds player + 1} player''' = updateRounds player'' runPlayer player''' runAI :: PlayerAI a => a -> IO () runAI mem = do field <- return . parseField =<< getLine let player = Player { playerType = PacmanPlayer , playerField = field , playerRounds = 0 , playerMemory = mem } runPlayer player ``` ## Makefile ``` physicist: Main.hs Pacman.hs ghc -O3 -Wall Main.hs -o physicist ``` ## command.txt ``` ./physicist ``` [Answer] # dumbpac This pac just moves at random, with no regard for the maze layout or ghosts or any other factors. Perl: ``` #!/usr/bin/perl local $\| = 1; # auto flush! $maze_desc = <>; while(<>) { if($_ eq "Q"){ exit; } $move = (("N","E","S","W","X")[rand 5]); print ($move . "\n"); } ``` Python: ``` #!/usr/bin/env python import os import sys import random sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0) # automatically flush stdout maze_desc = sys.stdin.readline().rstrip() while True: info = sys.stdin.readline().rstrip() if (not int) or (info == "Q"): break print random.choice(['N', 'E', 'S', 'W', 'X']) ``` [Answer] # randomwalk this pac walks at random, but not into walls ``` #!/usr/bin/env python import os import re import sys import math import random sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0) # automatically flush stdout # read in the maze description maze_desc = sys.stdin.readline().rstrip() maze_size = int(math.sqrt(len(maze_desc))) # turn the maze description into an array of arrays of numbers indicating wall positions def chunks(l, n): for i in xrange(0, len(l), n): yield l[i:i+n] map = [] for row in chunks(maze_desc, maze_size): map.append([int(c,16) for c in row]) # regex to parse a line of input input_re = re.compile('(?:([-\d]+),([-\d]+)([PGoOFX]?) ?)+') while True: info = sys.stdin.readline().rstrip() if (not info) or (info == "Q"): break # break a line of input up into a list of tuples (X,Y,contents) info = info.split() info = [input_re.match(item).groups() for item in info] # this pac only cares about its current location info = info[0] # which directions can we move from our current location? valid_directions = [] # we might consider sitting still # valid_directions.append('X') walls = map[int(info[1])][int(info[0])] if not walls&1: valid_directions.append('N') if not walls&2: valid_directions.append('E') if not walls&4: valid_directions.append('S') if not walls&8: valid_directions.append('W') # move at random, not into a wall print random.choice(valid_directions) ``` [Answer] # Pathy, Python 3 This bot use path finding a lot. Given a start position and end condition, it use the simple BFS to find the shortest path. Path finding is used in: * Find power pellets, fruits or pellets. * If it's invincible, chase ghosts * If it's ghost, chase Pac-Men * Flee from ghosts * Calculate distance between a given pair of positions. ## command.txt ``` python3 pathy.py ``` ## pathy.py ``` import sys import random from collections import deque DIRECTIONS = [(-1, 0), (0, 1), (1, 0), (0, -1)] GHOST = 'G' PACMAN = 'P' FRUIT = 'F' PELLET = 'o' POWER_PELLET = 'O' EMPTY = 'X' PACMAN_PLAYER = 'pacman-player' GHOST_PLAYER = 'ghost-player' class Field: def __init__(self, s): n = int(.5 + len(s) ** .5) self.size = n self.mp = {(i, j): self.parse_grid(s[i * n + j]) for i in range(n) for j in range(n)} @staticmethod def parse_grid(c): x = int(c, 16) return tuple((x >> i) & 1 for i in range(4)) def can_go_dir_id(self, pos, dir_id): return self.mp[pos][dir_id] == 0 def connected_neighbours(self, pos): return [(d, self.go_dir_id(pos, d)) for d in range(4) if self.can_go_dir_id(pos, d)] def find_path(self, is_end, start): que = deque([start]) prev = {start: None} n = self.size def trace_path(p): path = [] while prev[p]: path.append(p) p = prev[p] path.reverse() return path while que: p = x, y = que.popleft() if is_end(p): return trace_path(p) for d, p1 in self.connected_neighbours(p): if p1 in prev: continue prev[p1] = p que.append(p1) return None def go_dir_id(self, p, dir_id): dx, dy = DIRECTIONS[dir_id] x, y = p n = self.size return (x + dx) % n, (y + dy) % n def distance(self, p1, p2): return len(self.find_path((lambda p: p == p2), p1)) def get_dir(self, p1, p2): x1, y1 = p1 x2, y2 = p2 return (self.dir_wrap(x2 - x1), self.dir_wrap(y2 - y1)) def dir_wrap(self, x): if abs(x) > 1: return 1 if x < 0 else -1 return x class Player: def __init__(self, field): self.field = field def interact(self, objects): " return: action: None or a direction_id" return action def send(self, msg): print(msg) sys.stdout.flush() class Pathy(Player): FLEE_COUNT = 8 def __init__(self, field): super().__init__(field) self.type = PACMAN_PLAYER self.pos = None self.mem_field = {p: GHOST for p in self.field.mp} self.power = 0 self.flee = 0 self.ghost_pos = None self.ghost_distance = None @property def invincible(self): return self.type == PACMAN_PLAYER and self.power > 0 def detect_self(self, objects): ((x, y), type) = objects[0] self.type = GHOST_PLAYER if type == GHOST else PACMAN_PLAYER self.pos = (x, y) def update_mem_field(self, objects): for (p, type) in objects: self.mem_field[p] = type def find_closest_ghost_pos(self, objects): try: return min( (p for (p, t) in objects if t == GHOST), key=lambda p: self.field.distance(self.pos, p) ) except: return None def chase(self, types): is_end = lambda p: self.mem_field[p] in types path = self.field.find_path(is_end, self.pos) if not path: return None return DIRECTIONS.index(self.field.get_dir(self.pos, path[0])) def interact(self, objects): self.detect_self(objects) self.update_mem_field(objects) action = None if self.invincible: self.debug('invincible!!!') action = self.chase((GHOST,)) if action is None: action = self.chase((POWER_PELLET,)) if action is None: action = self.chase((FRUIT, PELLET,)) elif self.type == GHOST_PLAYER: action = self.chase((PACMAN,)) else: # PACMAN_PLAYER ghost_pos = self.find_closest_ghost_pos(objects) if ghost_pos: ghost_distance = self.field.distance(ghost_pos, self.pos) if not self.flee or ghost_distance < self.ghost_distance: self.flee = self.FLEE_COUNT self.ghost_distance = ghost_distance self.ghost_pos = ghost_pos if self.flee > 0: self.flee -= 1 action = max( self.field.connected_neighbours(self.pos), key=lambda dp: self.field.distance(dp[1], self.ghost_pos) )[0] # self.debug('flee: ghost_pos {} pos {} dir {} dist {}'.format( # self.ghost_pos, self.pos, DIRECTIONS[action], self.field.distance(self.pos, self.ghost_pos))) else: self.ghost_pos = self.ghost_distance = None action = self.chase((POWER_PELLET, FRUIT)) if action is None: action = self.chase((PELLET,)) if action is None: action = random.choice(range(5)) if action > 3: action = None # Detect power pellet if action is None: next_pos = self.pos else: next_pos = self.field.go_dir_id(self.pos, action) if self.mem_field[next_pos] == POWER_PELLET: self.power = 9 elif self.invincible and self.mem_field[next_pos] == GHOST: self.debug('Got a ghost!') else: self.power = max(0, self.power - 1) return action def debug(self, args, kwargs): return print(args, file=sys.stderr, **kwargs) def start_game(player_class): field = Field(input()) player = player_class(field) while True: line = input() if line == 'Q': break objects = [(tuple(map(int, x[:-1].split(',')))[::-1], x[-1]) for x in line.split(' ')] action = player.interact(objects) player.send('NESW'[action] if action is not None else 'X') if __name__ == '__main__': start_game(Pathy) ``` ]
[Question] [ # Please note: this is a [restricted-source](/questions/tagged/restricted-source "show questions tagged 'restricted-source'") challenge — see details below! Each natural number \$n\$ has 10 faces: its decimal representations in bases \$1\$ through to \$10\$. For example, the 10 faces of \$12\$ are \$[111111111111, 1100, 110, 30, 22, 20, 15, 14, 13, 12]\$, and the 10 faces of \$4\$ are \$[1111, 100, 11, 10, 4, 4, 4, 4, 4, 4]\$ We can then say that two numbers face each other \$n\$ times if they share \$n\$ faces, counting duplicate faces repeatedly. For instance \$12\$ and \$4\$ do not share a face as no number is in both of their list of faces, whereas \$6\$ and \$11\$ do: * \$\text{faces}(6) = [111111, 110, 20, 12, 11, 10, 6, 6, 6, 6]\$ * \$\text{faces}(11) = [11111111111, 1011, 102, 23, 21, 15, 14, 13, 12, 11]\$ Both \$11\$ and \$12\$ are in both lists, so \$6\$ and \$11\$ share 2 faces, and so face each other twice. Finally, we will say that any pair of numbers has a closeness, which is defined as the number of times the two numbers face each other. So far we already have: * \$\text{closeness}(12, 4) = 0\$ * \$\text{closeness}(6, 11) = 2\$ Notice that \$\text{closeness}(1, 1)\$ is \$100\$ because all 100 possible pairs of \$1\$'s faces are equal i.e. duplicate faces count multiple times. Your task is, given two natural numbers \$a\$ and \$b\$, output \$\text{closeness}(a, b)\$. You may take input and output in [any convenient method or format](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods). However, your program must only consist of pairs of characters that face each other. In order to determine if a pair of characters face each other, take their code points \$(m, n)\$ in whatever code page you are using to score your program, then, if \$\text{closeness}(m, n) \ne 0\$, then that pair of characters faces each other and can be in your program. This applies to all overlapping pairs in your program. So if your code is `abcd`, then `ab`, `bc` and `cd` must all be pairs that face each other. You may use any pre-existing code page to score your answer, but it must have existed before this challenge was posted. For instance, none of the pairs of letters in `print` (`pr`, `ri`, `in` and `nt`) face each other, so your code cannot contain any of those pairs of characters. However, all the pairs in `(p b>` (`(p`, `p` , `b` and `b>`) do face each other, so your code may contain them. [Here](https://pastebin.com/HcPBpddJ) is a newline-separated list of printable ASCII pairs that face each other for reference, [this](https://pastebin.com/2rugjawG) (Thanks to [@Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)) is a list of all pairs of integers between \$0\$ and \$255\$ which face each other, and [this](https://tio.run/##AT0Awv9qZWxsef//YuKxruKBteG4jCk9w74vRlMKOTVwYCszMcOHxofhu4wK4bmhMmXigqzColD///8iKHAgYj4i) is a Jelly program which verifies that a given string complies with the rules, according to Unicode encoding. It does take 10-15 seconds to run, so be patient with it. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins ## Test cases ``` a, b => closeness(a, b) 24, 35 => 1 10, 15 => 0 50, 11 => 0 18, 12 => 3 16, 15 => 2 1, 1 => 100 12, 10 => 5 30, 18 => 2 6, 6 => 22 20, 4 => 0 3, 35 => 0 23, 3 => 0 ``` Here is a list of \$\text{closeness}(a, b)\$ for all pairs \$\{(a, b) \:\|\: 1 \le a \le 50, 1 \le b \le 50\}\$, where the \$n\$-th element of the \$m\$-th row is the result for \$\text{closeness}(m, n)\$: ``` [100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 66, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 2, 52, 2, 2, 2, 3, 2, 2, 2, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0] [0, 2, 2, 40, 2, 2, 2, 2, 3, 2, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0] [0, 2, 2, 2, 30, 3, 3, 3, 3, 4, 2, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] [0, 2, 2, 2, 3, 22, 3, 4, 3, 4, 2, 3, 0, 1, 0, 1, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0] [0, 2, 3, 2, 3, 3, 16, 4, 5, 4, 4, 2, 3, 0, 1, 0, 1, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0] [0, 2, 2, 2, 3, 4, 4, 12, 4, 6, 3, 4, 1, 2, 0, 2, 0, 2, 0, 2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 2, 2, 3, 3, 3, 5, 4, 10, 5, 5, 3, 3, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0] [0, 2, 2, 2, 4, 4, 4, 6, 5, 10, 4, 5, 2, 3, 0, 2, 1, 2, 0, 2, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] [0, 1, 1, 1, 2, 2, 4, 3, 5, 4, 10, 4, 5, 2, 3, 0, 2, 1, 2, 0, 2, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 1, 3, 2, 4, 3, 5, 4, 10, 3, 4, 2, 2, 0, 3, 0, 3, 1, 1, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 1, 0, 0, 0, 3, 1, 3, 2, 5, 3, 10, 3, 4, 2, 2, 0, 3, 0, 3, 1, 1, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 1, 0, 2, 1, 3, 2, 4, 3, 10, 2, 4, 1, 3, 0, 4, 0, 3, 1, 1, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] [0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 3, 2, 4, 2, 10, 2, 3, 2, 2, 0, 4, 0, 1, 3, 0, 0, 2, 0, 0, 2, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0] [0, 0, 0, 1, 0, 1, 0, 2, 1, 2, 0, 2, 2, 4, 2, 10, 1, 3, 1, 3, 0, 3, 0, 1, 3, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0] [0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 2, 0, 2, 1, 3, 1, 10, 1, 3, 1, 3, 0, 3, 0, 1, 3, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2] [0, 0, 0, 0, 0, 1, 0, 2, 0, 2, 1, 3, 0, 3, 2, 3, 1, 10, 0, 3, 2, 2, 0, 3, 0, 0, 3, 0, 0, 2, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 0, 3, 0, 2, 1, 3, 0, 10, 0, 3, 2, 2, 0, 3, 0, 0, 3, 0, 0, 2, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 3, 0, 4, 0, 3, 1, 3, 0, 10, 0, 3, 1, 3, 0, 2, 0, 1, 1, 1, 0, 2, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 1, 0, 0, 0, 2, 0, 1, 0, 2, 1, 3, 0, 4, 0, 3, 2, 3, 0, 10, 0, 2, 2, 2, 0, 2, 0, 1, 2, 1, 0, 2, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 3, 0, 3, 0, 2, 2, 3, 0, 10, 0, 2, 2, 2, 0, 2, 0, 1, 2, 1, 0, 2, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 3, 0, 2, 1, 2, 0, 10, 0, 2, 2, 2, 0, 2, 0, 1, 2, 1, 0, 2, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 3, 1, 0, 3, 0, 3, 2, 2, 0, 10, 0, 1, 2, 2, 0, 2, 0, 2, 1, 0, 1, 2, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0] [0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 0, 3, 0, 2, 2, 2, 0, 10, 0, 1, 2, 1, 0, 2, 0, 1, 1, 0, 2, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0] [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 3, 0, 0, 2, 0, 2, 2, 1, 0, 10, 0, 1, 2, 1, 0, 2, 0, 1, 1, 0, 2, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2] [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 2, 0, 0, 3, 0, 0, 2, 0, 2, 2, 1, 0, 10, 0, 0, 3, 1, 0, 2, 0, 1, 1, 0, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 3, 1, 0, 2, 0, 2, 2, 1, 0, 10, 0, 0, 2, 2, 0, 1, 0, 2, 0, 0, 1, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 2, 0, 1, 2, 0, 0, 10, 0, 0, 2, 2, 0, 1, 0, 2, 0, 0, 1, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 2, 0, 0, 2, 0, 0, 2, 0, 1, 2, 1, 0, 2, 0, 1, 3, 0, 0, 10, 0, 0, 2, 1, 1, 1, 0, 1, 0, 1, 0, 3, 0, 0, 1, 0, 0, 0, 0, 1] [0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 2, 0, 0, 1, 0, 0, 2, 0, 1, 2, 1, 0, 2, 0, 1, 2, 0, 0, 10, 0, 0, 2, 1, 1, 1, 0, 1, 0, 1, 0, 3, 0, 0, 1, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 1, 0, 2, 0, 1, 2, 2, 0, 2, 0, 2, 2, 0, 0, 10, 0, 0, 1, 2, 1, 0, 0, 2, 0, 1, 0, 2, 0, 0, 1, 0, 0, 1] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 2, 0, 1, 1, 1, 0, 2, 0, 2, 2, 0, 0, 10, 0, 0, 1, 2, 1, 0, 0, 2, 0, 1, 0, 2, 0, 0, 1, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 2, 0, 0, 1, 1, 0, 1, 0, 1, 2, 0, 0, 10, 0, 0, 1, 2, 1, 0, 0, 2, 0, 1, 0, 2, 0, 0, 1, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 10, 0, 0, 1, 1, 2, 0, 0, 1, 0, 2, 0, 0, 1, 0, 2] [0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 1, 0, 0, 2, 2, 0, 1, 2, 0, 1, 1, 2, 1, 0, 0, 10, 0, 0, 0, 2, 1, 0, 0, 1, 0, 1, 0, 0, 2, 0] [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 2, 0, 1, 1, 2, 1, 0, 0, 10, 0, 0, 0, 2, 1, 0, 0, 1, 0, 1, 0, 0, 2] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 1, 0, 0, 1, 2, 1, 0, 0, 10, 0, 0, 0, 2, 1, 0, 0, 1, 0, 1, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 10, 0, 0, 0, 2, 1, 0, 0, 1, 0, 1, 0] [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 3, 1, 1, 0, 2, 0, 0, 2, 2, 0, 0, 0, 10, 0, 0, 0, 1, 2, 0, 0, 0, 0, 2] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 1, 0, 2, 0, 0, 1, 2, 0, 0, 0, 10, 0, 0, 0, 1, 2, 0, 0, 0, 0] [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 1, 0, 2, 0, 0, 1, 2, 0, 0, 0, 10, 0, 0, 0, 1, 1, 1, 0, 0] [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 3, 0, 1, 0, 1, 0, 0, 1, 2, 0, 0, 0, 10, 0, 0, 0, 1, 1, 1, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 10, 0, 0, 0, 1, 1, 1] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 2, 0, 2, 0, 1, 0, 0, 2, 1, 0, 0, 0, 10, 0, 0, 0, 0, 2] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 1, 0, 1, 0, 0, 2, 1, 0, 0, 0, 10, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 10, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 10, 0, 0] [0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 10, 0] [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 1, 0, 0, 2, 0, 2, 0, 0, 2, 0, 0, 0, 1, 2, 0, 0, 0, 0, 10] ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~37~~ 27 bytes ``` b ȷ2½RJÞ©¤µ€$ p /Aµ~E)UCCTL ``` [Try it online!](https://tio.run/##ATIAzf9qZWxsef//YiDItzLCvVJKw57CqcKkwrXigqwkIHAgL0HCtX5FKVVDQ1RM////NiwxMQ "Jelly – Try It Online") A monadic link that takes a pair of integers as its argument and returns the closeness as an integer. When run as a full program implicitly prints the result. Note encoding is using the Jelly codepage (available at [Jelly](https://github.com/DennisMitchell/jelly)); byte count and neighbouring pair closeness both reflect this. [This TIO link](https://tio.run/##y0rNyan8/z9J4cR2o0N7g7wOzzu08tCSQ1sfNa1RUShQ0Hc8tLXOVTPU2TnE5//RSQ93zrB@1DBHQddO4VHDXOtDm8tUuJAFDs/wyny0cd2jhpmH249t4nq4c6HR4XagUZH//ysRY4USAA "Jelly – Try It Online") has a footer that breaks the program itself into overlapping pairs, converts each to the codepoints in the Jelly code page and then calls the code itself on each pair. The code section actually isn’t used; it actually evaluates the copy of the code seen in the argument. A (possibly) minimal implementation of the closeness algorithm without the code restriction would be 9 bytes `bⱮ€⁵ŒpE€S`, so there’s effectively a 18 byte cost to ensuring all pairs are close. [Test using version of OP’s link](https://tio.run/##y0rNyan8/z/p0cZ1jxq3PtzRo2l7eJ@@WzDXw50LjQ7P8MoESQBRw8zD7Y@a1jzcteD///9KSQonthsd2hvkdXjeoZWHlhzaCpRSUShQ0Hc8tLXOVTPU2TnERwkA) [Verification of closeness](https://tio.run/##nZS/SgNBEMb7PEUKG2HBmdnL9RJsxEq0CgERbCSFrY0QG9/CykawDTZqcWl8Dl/k3NuZ/b8Xomz2ktzd99v5Zmb39ma1uu/76@n3O3Wf56fb5@61e@k2P49vB9O76dFxt3k4Obyczy/Oeg1q@3W1fTLPhs/6o@8XkwUCqH@PpZosQLWtomzgX/SkZk6nI33OwHE9qQZUzECvKVVY0xsZGCWPJnGwg5DoFZHVsl7Le25SxT86vbZTK2yNdmbmnoR0/UGGJhWqtX/QKuJZeAp6Nj4sjWC@ZhyODEjqgeEar9/Y0RqpIQwu2AFFcWCWP/HPizDDx7AXgfXulk4JXIdBpe3EyAVfyekdVgtlsL8PIV7fFSnEgWB/oFU3NULQByjaF4mbEPyeYAKzXC9QqsckWZ6AYguko3Q9/lBmR2DhLkLNv1OCdLUlgHehJdFZ/LkL8KW3S44QUn3c6nHKIwIKVpourz8lVXQECgSSGPjFIv40i9q7GCOU@piC0guhqjlhTO8I2hNc8pAfCiHvPyi2mI5iyAhY9k@dEGojB7sn1PMXjm3aRTAPav4rx5S4KAnj@csJ6AkoUWF1/0NyWFPUVRQRZAPBcrL8BQ) of every pair between 1 and 30 using the data from the question (will print 1 if all match). ## Explanation Code explained below. I’ve omitted the spaces since they are ignored here. I’ve indicated steps that are only there because of the code restriction in square brackets. Note many of these aren’t no-ops, but they do not change the final result. ``` $ \| [Following as a monad] µ€ \| - For each integer in input: b ¤ \| - Convert to each of the following bases: ȷ2 \| - 100 ½ \| - Square root R \| - Range JÞ© \| [- Sort by sequence along each list] p/ \| Reduce using Cartesian product A \| [Absolute] µ \| Start a new monadic chain ) \| For each sublist: ~ \| [- Bitwise not] E \| - Check whether equal U \| [Reverse] C \| [1 minus this] C \| [1 minus this] T \| Convert to list of indices for each positive entry L \| Length ``` Finally, [here’s a handy TIO link](https://tio.run/##FVLpUlMxGP3vU6DijhsKKu64srjjgitbQRABARfcprcsxRZU2hlaVKBAW0YpSAu0SW4tM8m9mZa3OHmRGv4k@ZLzLTnntDna2/vy@QYVX1KumDLWQEa2FJeUgiSFu7maR0Smrka/VNrpQuWcsH2gQR0W86hei5QzCNPLV6RHeqo2812x2s3N@auio9fR4ujuKdPn8r5eR09Ba0dBY2eTo6u@xaEvJ@30JrJNGRme5Ml8Ps9n@Cyf42Ee4VH@m8f4El/j//i6Rokh4RbfxZgIiKDtE1NiWkTFvFi24tmUiIuUILZfZAq2btteuGPnrt179u4r2n/g4KHDxUeOlpQeO36i7OSp02fOnjtffuHipctXrlZUVlVfu37j5q3bd2ru3rv/oPbho8dPnj6rq29obHI0tzxvbXvR/rKjs@tVd0/v6zdv3/W9//Dx02c95jKnPMFXlLGqiVJGUhkpZRBlUGUwZZjKSCvjn/6RNKRbUzIm/TKoiZWTMixjMpEN5/xyOBeQvlwoF5UTuXguISMboVx6wyUXN7zZCFgIZEBLAEZAwjA9IAktBagLdAjmCOgP0FnQGMwwaAZsGOYqmC8bBXFZGu2xxkGmLF1m1lq21kGdoAPZJdBxLRxoCPQP2BCYB@yrbYLNgAyCjIJRkIjWEmQFJAXaD@qGOQr6E3QOdJHPiwGwLzDXwPzZeZB@S2O9VgBk2tJF5mzdyAAdzP4FDYBOgM6ALoC5wbxg3@w0X@Cm9os2kbaENsB/) to generate the pairs of integers 0-255 as well as characters in any codepage. The link as provided will give the pairs for Jelly, but you can change the argument for any other code page provided the characters exist in Unicode. They should be provided as a single string from 0 to 255. [Example for 05AB1E](https://tio.run/##Dc/XUlNhGIXhc68iKvaOggpW7IAdC1ZaQDACCpbY5s8GQmiWJCodktACCKTt7FRmvpUdZ2Tmn3gJ@W4k5my9s46eFqPJZM7l6ti3wsoyW0JZbXBTYVFxVlPR21hJs0jWVOWfcj1ekI0NUKAiH9UsxsvMncYOQ3Orob6twdhe22QsIZXFRGkul/sz8dcufdIvAzIoQ1KVYamRmvFntEw8k/inSId0ymEZkR7p5b5ptvWzbYhtk6xYWFFY6WKlm5UeVqyGzVu2FmzbvmPnrt179u7bf@DgocLDR4qKjx47XlJ64uSp02fOlp07f@HipctXyisqr167fuPmrdtVd@7eu1/94OGjx0@e1tTW1TcYG5ueNbc8N71obWt/@aqj8/Wbt@/M7z98/PQ5Hcpj5BiL0bSdxSSLORbTLFwbVhZren5FdHvKqifSakqwGGYxkofnkSzcLBwsnBvj3O3WXSyiuiPVqyd1LWUhF7nJQzM0S3M0TwvkpUVaomUZoxVapTXykZ8CFKQQqRQmjSIUpRjFKUFJWoeABQq60I0eWNELG/rQjwEMYghf8BXf8B12OODED/zELwxjBKMYwzgmMIkpTMMFNzyYwSzmMI8FeLGIJSzjN1awijX44EcAQYSgIgwNEUQRQxwJJLH@Hw), without the preceding integer bit (just characters). [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~59~~ ~~52~~ ~~51~~ 43 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` εηθA~TLTBB™ÿćV9yΓиΓdJRzzªh}¯``ðð~V¢ 2 D//wO ``` Ok, that took a while.. Did it by trial-and-error, but I have the feeling that creating a brute-force program would have been more time-efficient now that I'm finally done.. But, it works! -9 bytes thanks to @Grimy. Uses the [05AB1E encoding](https://github.com/Adriandmen/05AB1E/wiki/Codepage); the characters map to [these `0..255` values](https://tio.run/##yy9OTMpM/f//6L4jbYcnBGcf3vH/PwA). [Try it online](https://tio.run/##AUoAtf9vc2FiaWX//861zrfOuEF@VExUQkLihKLDv8SHVjl5zpPQuM6TZEpSenrCqmh9wq9gYMOww7B@VsKiIDIKRC8vd0///1s2LDExXQ) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/c1vPbT@3w7EuxCfEyelRy6LD@4@0h1lWnpt8Yce5ySleQVVVh1Zl1B5an5BweMPhDXVhhxYpGHG56OuX@/8/vF7nf3S0mY6hYaxOtJGJjrEpkDY00DEE0aYGEHFDCx1DIxBtBhE31AGLGukYGgBpY6AqCyBtpmMGMsNAxwQkCDHJCEiDKJA5sQA) or [verify the program itself](https://tio.run/##yy9OTMpM/a/0/9zWc9vP7XCsC/EJcXJ61LKI80h7mGXluckXdpybnOIVVFV1aFVG7aH1CQmHNxzeUBd2aJGCEZeLvn65/3@lQ8sOrTi0Up1T/fB@K9tD2@wP73nUMKus0l5J4VHbJAUl@6P7jrRVBme7wAUOrdMLO7xe5z8A). Explanation: The base program I started with was 12 bytes, which was either [`εTLBćy×š}`¢O`](https://tio.run/##yy9OTMpM/f//3NYQH6cj7ZWHpx9dWJtwaJH////RZjqGhrEA) or [`vyTLBćy×š}¢O`](https://tio.run/##yy9OTMpM/f@/rDLEx@lIe@Xh6UcX1h5a5P//f7SZjqFhLAA). Here an explanation of the first base program (second is similar, but with a loop instead of map): ``` ε # Map both values in the (implicit) input-pair to: TL # Push a list in the range [1,10] B # Convert the current value to each of these [1,10] bases ć # Extract head; pop and push remainder-list and first item separated to the stack y # Push the current value again × # Repeat the "1" that many times š # And prepend it back to the list }` # After the map: push both lists separated to the stack ¢ # Count for each value in the second list how many times it occurs in the first list O # And sum those counts together # (after which the result is output implicitly) ``` Note that the `ćy×š` is to fix the base-1 conversions, since in 05AB1E any number converted to base-1 would result in a single `1` instead of \$n\$ consecutive `1`s. That was the easy part.. I then had to add no-ops to comply to the challenge rules.. I've first created a list of all unique pairs of the `0..255` values (since the one in the challenge description is incorrect I noticed..). And then used [this helper program I created](https://tio.run/##TZw5DgUxUoavMhkJwfNWy0GQkEYEIBEQEUxMygG4AxIXICUBEgKuNNC1/H9F75NflV3trVy2u//xT3/7d//w93/@i//99z//1f/@@3//x3/985/@89/@6X/@5a//81///Oc//nH/5R/O3/zlH77fW7@vfqV@tX6tfr1@169hfXAqh1M5nMrhVA6ncjiVw@kczshhnYLdKQeZ91@vs9NOcahnRrdMuGXCLRNumXDLhNsm3Dbhg1Zdrbs75XTKba3b@cjtAjofQz4/lPEig1dmvTLrlVmvzHpt1muzPtgNrbM7k9Myp/96rS6vC4D6jzkGSVkhZYWUFdJWSFshbcUHt0EaWnu31mm4rfVaWE4X3X85ywrSMkfLHG1ztM3RNke732i3nnY1fdDqu7VOw22t18LaKY4iRmEhZWWQtUHWBlkbZG2QdUVZV5R1RVlX1AethRIEWtn5vv@QwX6R5m2AtwHeBngb4G2Ad9V4W@JdR9515F1H3n3@Ays4rXVbWDpnaWGDGT9YtgV5R3Hr1@YGbdABXZCAqGtNWX9ByGVD4@DfA92HtDQ5CPkZbfnRwDNKSYEFsxfMXjB7dU0HKchA3pS1HYRcNjQO/j3QfUgTASE/oy2/YSBLqWI2zN4we8PsjXrfMHujtjfM3qj3j5BLPcBGC@zuOx9daDykKdIMGg6q@SANpA0vlQ4e4OABDh7goAUO6h3OJQi5VNWc7vpB1nSgcZDfhcZDmiLNoOGgmkvSVNrwUgm@Z8H5BCnImqotLh7g4gEu2uJiNHzkTQcaB2kXGg9lKNIM5NBdi5jT0XqwGl4qyEDeVA3wYPWD1Q896KEHfQS5g9Iu/r0oQyBn@Neg4bBgbfxdXnkJrIY3C/KmUhHUusBqQbcRdBtBtxGMAOnp8yOBrkGuJs7AqiWFNfBmH5U1cGxBB/RAAoJu9QFFd1bMjYq5UTEjKmfE8IOZCg8WtED894K06UDjQK7a1jDRGawxTHmGKc8wYximPEMv/dwzculpMBwpU2U8QJYD1xe0QQf0QNZ0oHEgdy7Imx7kHnIWbVLoGnQNpTlyWT8Irs1UoYnZRBv@MOiALkhABvKmbKEg5HKge6B7IXch90iQU6QpcnHoVn8PXEQasYR2Z2tu@MugC3ogBXlT5Qi/GoRc6rFWD4iPLuQu5B7KeJBT/KvW5NBdP6jU9B/IApcidVcNwJ8GPZCArOlAox5ro9022m3jsXaPsQ1fHAS5hzIe5BT/qjc5dP00rR@Uyz0EsuilSN1VF/C3QQJSkDcdaNQDHrTgabcQZCDoXshdyD2U8SCn@Dfdx0cOXb9N6wfltfD/YtFLkbqrLuCPgxRkTdWW8NFBB/RAyOVCo1rwti/8SPCvIBdDmkEj55gdoSqUF60uXxnIchaz2iUA3x1kIG@qJoQ/D7ogASGXC42LXARpAl1DWs6d@3FuCYR2txcj4MBLNea1SwBOPcibqsEEDSZ4HEGDCR5H0DcRE3/0kIsgTaBrSDNpKmccuAai6HLRgZdqzKtCma14CMTFQQf0QAIykDddaDzkUq2j7bk/MsiVbw5cxE2BjbIr9t0GI7GACLogynlTDRLDIDE4qo@QVnVu7Zw/Uuga5MyayiUnMnVBvYLfwIOsKhDejmfAEiLogSBXz@AYEI6Z7FtWQPchrarcO8D9SKFrkDNvWr9LZOqCem2ABB5ktVPg/PoZDhYMQQ8kIGjkcx0sIoKg8fDvg65AV6HhkKs1ROAmnoHQqjFwFsxdMBdLgoMlQZA3ZTMcLA6CoPHw74OuQFeh4ZCrcRy4iWcgtCqMPxvmIsQ@cPUfVe3C1R@4@iDIPcg9yKX7/0jxr@JfRS6ONIdGjefAzdTDVAHWCjxwI9ddtXrwYAi9D1z8R9UO3B@Giw@C3IPcg1y6/Y/qwbinjKXAwQIgCBrlRQI3Uw@UamH@YS3MAzcs2tUSFw928WAIzj@qtoOTDxIQ5B7kHuRyCfBRPRgC@yDk4kgrpxm4mHqYeqBVa/NzsTYP3DBpl50PT/bwZAjggw7ogaDxIPcg9yAnSKsne2g8bAMcBP@He@CH@wCBh6nVIrGlgaz2DyXtA7Vd40jwPIJuKWgzQZthC@CjB7l6HmwLfJTxxEeGnA0a3VKCIONw1yDwoMTaOQtUCFS8EVi9R2G7oucpWkUxa2DDIAhyNU9jE@GjDBo@MuRs0Oi2UMQPh3sMgQcl1qZZoEKgQonA6h8G2w19y9AChr6F7YUgyNWkjS2Hj6oFDLZj8@FwoyER2rWYCTwocT3KKgQqSgis8cut/uN4DEeXcjQGNuUP9hiCIFeTOfYdDvbqD/YdDvcYEqGzNgUOylk0bSkEds6L99dmXnj0C48eBLkHuQc5gVz6@48UaQYNg4ZBrtYxiUzN@r1cDgTSyNoGDDQIVGhzF54Cjv7C0QddEOQe5ARyuQz4SJFm0DBoGORqcCcytSqaq4RAGrmyFwcaBCqiuRtPgZVAkDVlNwq6IGhU@@yOWS5WBx8Z5Az5OTRqjZaIvGt1EEjLFguq6OVurNzugenw9UHeVJ3soFEQ9n9UjXLahVz4/48Mcob8HBp90hyIvGuRFkjLFgtaBoFaxV2E7JfnyRcjBd48SEDQqPq/PeNeePiPHLk45HokBKK8daBUE1Qgs18G2fJ@F645aIEeSEHeJNCoWn89zV447iDoOnJ2aDg0eiA8RF6Xfj3wEh9lWdJyCOwaSnDNQRskIGuq5xH0J7jwIG1S6Cp0HTk7NBwaPToEUdilgw@8xEdZlrQcArvGF9x10AEpyJvqeRSdDG49yJoUugpdR84ODYdGDxllF6TTD7zER1mWtBwCuwYdXPhFWP9RtY@hv8Gtf1S9AA7@o1woXuPVDQb4gZup9xAVyLzaTkNMc@GZLwL2j6q2ca7@UbUkvPXl0XriSHXgZuq9RAOOzBw2VTzy4Icf4u6Psgs8HJ0/ROBB2mRIy@Z@PE5PxP/lBwI3UzfVcjYMZPGLJSyHyRVGBqYPfHDAD3H4R9kLHo7QHyLyhy38h8P0j7I/PB6rJ15gXdJZWPElUq3u4yyEhYEGO5cDK1gMTD/4NsxHXP5RdpMg/KtIyy4YhLTqOomH@ICLspt4qPaYyvKXwdDNIiokfDytfwf2I/z@qHrU6UnlIfx@OEkPQlr3qMOGOAggHp1y4CYeqj2msvyVXv8xak88wJxiHmLrIAF5k@Jfxb/Vc2@vkIKsqTvXZZNwSz5wQatHCUPzRObwKEvzNovYVW1xv@1HzFTssgdpUz3U68VrkDXViHm9dgrypn6mx3bixvyj9w7cTD2LSLVHWZrS7fQQ2gY@ClSjY6/94S7aR/V4uJYW5E0GXYdcPwnvrQVu4hm4iQqsehbEtC@uGhhwQaCHkcJo7LJ/VBWBa2wf1TSg6HK42/YUserjPbfATTybeIgGFAqw1F2tqohrA6v2cb/tYdf94VA/CP/W2Dd0KetF06NPDlxM3cSy2bC@TXSgUIClducxxLMPt9we9tYfDu@D8G@NcsfY9l4OPTrqQObdfsNpqGM7MTAXsYFCAZba3SQwL2f@2tIgbVL8q/hX8a/h37qR@evFaRA0qsITLxEZ1dlH4CHeH5FqOe8LY@8P69RHGIbLwoOsdhYfZTUE4V/Fv4Z/s@cHMQ0a1R6Jj4iM6gAk8BDvIlItXYEw/JaFox9hJC4bD7Lbf3xUbbPxIDh@F0TYgv33IKZBo5tmw3skIqNyJIGHeDeRajk/CoNx2Tj/EcblcnoqDdImQ5ohLQeGYG9d6LsD949IgXuIl4hcyycII26Jg3jkUMG33J41BVe3BU5ZuB0udL@BexEfsGy57AgXC@9Ag8BmZnXsIQ@3oXFf@6Mahty2DqxHeZjuEgVYBjy24ENkH2jIoTsl97VFemr7yEi3qUaSYNmSiP@74QRzW6IQFVg1xH3qRKo5Uru3CWJ1UUxpCgsVo14xRBSr3kT8362pWPUKr3snGjBjEuFudCLVHKnd3xTRtyDi/MhI0lTjwViZhlWG0LkJr4YLL7cJz5kD30CqPao5UjfzrXhaEH9@ZCRtKrfgrEzHkkLo1IS3wIWX14SnyIFloLPhHatYYaQqzsEbF/TCBoUL@8hI1pSTo/5QmcrtYaW3Um4PK0@LA9OqRBRa@5OBjsxqRAemv1M4pI@M5E3phnShBpX7vUrfo9zvVZ4KB5ZVC00cKJR1ZLY3BHZ6L0XIqNisVbgS5bat0mkot20TH1AoKxCo2DCQOez0NYpIT7HRqnALyi1XpS9QbrkmClAoKxCokC6QOdS@jCJAU2yXKj2AcudUGXUpd04TFSiUFQhUAKbcRA1Mx6GIoRR7ncp5P9GAiwKHAtUID/48MF1joFwiZet5GUQpd0MDq5LgBBSblkonkOjARYFDgWomwWpQ6QQCyy5B7BrosKBi18BDrFrE3K/YfQySpvICgdWpuSeZqMBD2UvZGjR0CIHCIoQ5OMzaPxSxDzFdtcIPfOQkbapZNrDGgmFZkmjAw9RL2RprdA6BQjWlrKO0iocCmW9tTyl8wkdOsqaecZ0jyFnJjtVM4GHqpWz1PofXDRSqKWUdpVVMFMh868De4B8@ymnGfph@jYGN8TZR4IFW2RX4KPCopkxVyNZEGFhvjP0Q3dvCnJNowOyhxjtCgRnNBuYICHwUeFRTCNRcGFgvqy1sb9nGrJPowHoLbWMpEphDI/EBHwUe1RQCNRsGVlVv7EHZwbQSWC/bHfScwFwKBGY3TxTgo8CjmkKgprvAqt@DrQq7mC0SL7Da7WLUBW4K5ILCGBcEVi/hazOJzMEgsFlahb/2aAN31IzOwHjylUiBerWQoUFg9RK@BRMoTDVgbUkZr8Uab54Y98KME7/xuMq4@k804GVqdRhhYwk8qfEGqwm2mIyXWY1XSIx7W8ap3XjGZON9TsV6IvAytfqOsoUU64lAA9YUGVh9kndBjHtVxhnbeEPEuHAPvJStwWBYVCUy1YA13QVWR@RFDuPek3H2NV7vMC7IAy9lq6c6u4bDSwcasOczxyLTedST6MB6NZQL7cA3kALC1HRXgYbMKqAOzJp0Hs0kbuCmQHYC51o68QEfU4VqMlId6BComDowK9V5MTLxADcF6nXbjWVlogAfU4Vq9QYuN2kCHQIVNgdWVfMSY@IFbgrkuHBebUxU4GOqUC0XQs6dmECHQEXGgVXrvG@Y@ICbAtWwvIWYaMDHVKFaLsYCc50Q6BCo6TWwav3RhocRG7gpUDXJC4OJDnxMFapV/@UlhECHwGYRtUx0oQ2CweucUwOrJrmuDpSBzEwHModcs7lw8ApCWOfCONGAm6lVfVwjB8pAAepA5pArMY@JFAIVpToXuYkO3EytOuN61/nSX2CVFgi1WpQFbghUdOrOWYN7GIHVEblKdb6WF1hFBEKtll@BGwIVZf3/8o@vf/7mS@jcNk@WwTZkXMC1yEpu3cXXOH/jHfEf97CTZbANGVdwLaCSW3dj3CbXy57JI/0KWSYb2YauM72WR8VK7pf8DwZrcpd70E2Tr5JlspNt6DrTK6ArNnK98vnjBnGxkNuGiy6bXC8z/7hcTJaRriPdqNuvsybLYCfXS6i/N@zhCjH5jPS2gevFZB1slEd/4Clscr3m/pNRFpeCyWekd1lcGCbrYKM8@gPPTJNfpesoi2u@5DPSuyyuAJN1sFEefYCHncn1WvzPxvjl6WNy9z0bZXHVl6yDfeRTL@P/bLQ1TyyTez7xMcZ5mlhs5C6Xq75kHewjH2f@GIM8gUyuOWdxmZd812An1@v4@dWPwT50nXl2H0t@5JqLFpd2yfUJisWLOcVK1sE@dJ15dh9LFnLNaYtruOJHviO9v@mxEWYky49sg53593jPr3Js8h7p1cfWGTZwtzT5jvTq/8lOlkW2wc78y6sl95dRDgLG5Opv6w4buHeafEd69cn8KsZv8CYbGXXC7dbkxXzwJZcxH643bOD2afId6TUu8nsXQ7fexM9vXpBRJ2NuXDx1S94jveaB@ARE2yCcNxY3S5N7vMiwQbg2yK9ZkFEnwrlr8WQteQ/5rn9ugRY7uceOjnKV64f8hgUZ9aCcuxZPzJL3kO86tzFv2Bi/NsaOjXKN64pgI7e/SFby/g0ueR/zho8x4mOM@CjLuZYINsqgzp1rhvzqxCL3p3O4x1h8yW@k19jcDI@TdeTj5C53j/lz8@AqufzFXqPcsT7cPHNKrrGwGROv8X2DZCf3mmSPuXTzbCq5/MXeo9yxbgx@I736/97j2fnhgWQn49nH/Bm8mX8FqGufUe5YNwa/kV79f5/x7PwiQLKT8exjzgzezL@i0pWv4OtgI7@RXv1/3/Hsl2uJYCfj2S99aL7Yz/wrFF35trwNdvIb6TUWNuPcZCfjeR99aHB/MErGR58YzBYbWYe8Mx15CufbzZB2bR7jJ8tkJ9d6YDNAXfleug42cs1Rm0fvyTK4@@f4DE2@HW6DnXyp2zHO9jEPjK/BBHffY7SZ3Hk657o9Ys/g/joVTzOSZXD1qzNizMOrWmu8Yp18qYuvd/F4IlkG97e0Rox5eG9qjTehky9124ceHj0ky@Dqk2fEkuMt5ORL@fZBh0cJyTLZyNUnz4gTkynfc11wtenhgUCyTHZy9ckzYr1kyvc8Ftxt@jiOkp2sI10NDJsf5@3gPdL3kO/25QXXNd49LXZwz8PBnY/glD6525S3Ttd4EzS51snjtdDkzkfpW/N90WprXgVd473M5Fpbjpc0k/ubcEY/NV7ZXMfHeOFLksm1PhxvTCZ3Pk6/Ey8k1rgI1slC7s@0/bjWvdwYTy4/Ei8F1lgI1slKrjVbvDm4JlOm/UK@rqdknWzkWoPFi3xrMmV6/r9jTAXrZCfXPkC8V7cmU6ZOgNcd@yeXJ27JFVtdbgon1zr8jn2Py@Ox5IqDLg/IksvX3LF3cXmWlVw@6/I0K7n8yB37D5cHT2u8CVXs4J4bg@8eXOljb@Ha6D/G9ckdvunyWGmN15mKK33sFVwf/ce53rjDH10eE63xDlJxfbZv9PN8/2ewU6Z9RPCmTM/hb/idN/p5voozuPpAvoxzyZsyHVO/4Wve6Of5UoyTq2/kazGP3B843IyLH4/AV76S8iP7ZAP3/B9c81Jwrc0ej7RXvBJS/TbYyd3WyUqueemNeDnevbDBTu72fTw3Tu7POI44N958sMFO7nXFGz7i8dZPcteVsg8/3rtZb8Sbb/iFx1s4a7ydsOJdABvsZPSH4Qseb8WsuJNvg52Mdh9z/uPNlJWX3wdX@8b192pfGXO78HbhylvmRq55IO6Z/5jec7jw4t@SsY@U7OT@ICbv6S0Z@zx5q/o32Mg1P8jYh8mbz2uwk2vsy9gnydvJm9yf4HycH2Ts/eYN4UOueTi45gEZe7Z5S/eS@8OeyjEuY39Vxl6B8JvMyf0p0LE@l7EvKiPel/E5ZBlzoIy1t444PdnJa6T3Bz7H/Kb8mGCxk2se0zF3Kb/Il9wfF@VVzeQaa8rP2iX3J0h5szK5xlRccqx20bH/lvcgS/exLZSnoMn9wVJhH9YR3ylPLJNrnlEdMiNeUx31ppxP1IbMiMXURr0Z5w31ITNiK/VRb875wUZ8lOzk6s82Ypzg/mTq2Fs2vmyRfAZXvzW@5pB8BpevMb5@UPzIZ6SXH8nLP2@wkM9I78@3ypAR1mHwGenVb/P6jA428hnp1W/zqosNdvIZ6dVvbeytBd/B1Vd97H0F1zzpYz8quOZDH3tEzk9XLR/7Ns7vPS0feynB1e4@9j2Cq63jCL6ePY/ji5XPmEfkxcbnSq6Pxfp4Fkcb7TwX3uT@iOvCsyTXV@bijLW@pPfjnLDj3LO@Sffj2N8/fgdq//i9pB1nc/WxyjwvK3sMc@CO86OyJ850yoY4Z6lyV8Xmf/N/) to get all characters in the 05AB1E encoding facing the character I've input in the header (you may want to collapse the Input section on TIO in this helper program). As for the resulting program and how I (and @Grimy) have made the no-ops: ``` ε # Map both numbers in the (implicit) input-pair to: η # Pop and push a list of prefixes of the number θ # Pop and push the last prefix (the number itself) A # Push the lowercase alphabet "abcdefghijklmnopqrstuvwxyz" ~ # Bitwise-OR the number and alphabet (results in the number) T # Push 10 L # Pop and push a list in the range [1,10] TB # Convert each to base-10 (they'll remain the same) B # Convert the current value to each of these [1,10] bases ™ # Titlecase each number (does nothing on integers) ÿ # String interpolation (does nothing outside of a string) ć # Extract head; pop and push the remainder-list and first item separated to the stack V # Pop this 1, and save it in variable `Y` 9 # Push 9 y # Push the current value Γ # Actual no-op; this character is unbound as any builtin и # Repeat the 9 the value amount of times as list # (alternative for the `×`, since the builtins facing `×` were useless; # this does mean I need an additional join `J` though) Γ # Actual unbound no-op again d # Check for each 9 if its non-negative; which is truthy, so they'll become 1s J # Join the list of 1s together to a string R # Reverse this string of 1s (no change) z # Take 1 divided by this number z # And do it again so we're back at this number again ª # Append it back to the list h # Transform all values to hexadecimal (since we only care about equality, # it doesn't matter the numbers are now hexadecimal strings # - except for a weird bug where the string `"3E#"` equals `3`..) } # Close the map ¯ # Push the global array (empty by default) ` # Push its content (nothing) to the stack ` # Push the inner lists we just mapped separated to the stack ðð # Push two space characters ~ # Bitwise-OR between the two space characters V # Pop and store it in variable `Y` ¢ # Count for each value in the second list how many times it occurs in the first list 2 # Push a 2 \nD # Duplicate this 2 // # Divide the 2 by 2, and then each count by 1 (so they remain the same) w # Another unbound no-op O # And sum all counts together # (after which the result is output implicitly) ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 27 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` 5+5ɓz2z2b ð€Z<Ƈp /6EE¹?ƇTL ``` A full program accepting a pair of integers which prints the closeness integer. [Try it online!](https://tio.run/##ATQAy/9qZWxsef//NSs1yZN6MnoyYiDDsOKCrFo8xodwIC8qNkVFwrk/xodUTP///1sxMCwgMTJd "Jelly – Try It Online")* Or see the [50 by 50 grid](https://tio.run/##ATYAyf9qZWxsef//NSs1yZN6MnoyYiDDsOKCrFo8xodwIC8qNkVFwrk/xodUTP81MCzDh8Klw75gR/8 "Jelly – Try It Online") (takes ~30s when not cached) For verification, the bytes used (in hexadecimal) are: ``` 35 2B 35 9B 7A 32 7A 32 62 20 18 0C 5A 3C 90 70 20 2F 2A 36 45 45 81 3F 90 54 4C ``` ...which, as a list of integers, is: ``` [53, 43, 53, 155, 122, 50, 122, 50, 98, 32, 24, 12, 90, 60, 144, 112, 32, 47, 42, 54, 69, 69, 129, 63, 144, 84, 76] ``` ### How? ``` 5+5ɓz2z2b ð€Z<Ƈp /6EE¹?ƇTL - Main Link: list of (two) integers, [a, b] 5+5 - five plus five -> ten ɓ ð€ - for €ach n in [1..10] do f([a, b], n): z2 - transpose [a, b] with filler two -> [[a,b]] z2 - transpose that with filler two -> [[a],[b]] b - convert that to base n (vectorises) [[[xs]],[[ys]]] Z - transpose -> [[[xs],[ys]]] Ƈ - filter keep if: < - less than [a, b] (always true so filter is a no-op) / - reduce by: p - Cartesian product (get all pairs of wrapped representations) 6 - raise to the sixth power (vectorises) Ƈ - filter keep those for which: ? - if... ¹ - ...condition: identity E - ...then: all equal? E - ...else: all equal? T - truthy indexes L - length ``` --- Combining the start of [Nick Kennedy's](https://codegolf.stackexchange.com/a/196386/53748) and the end of mine gives us a joint 26 byte answer!: ``` b ȷ2½RJÞ©¤µ€$ p /6EE¹?ƇTL ``` [Try it online!](https://tio.run/##ATYAyf9qZWxsef//YiDItzLCvVJKw57CqcKkwrXigqwkIHAgLyo2RUXCuT/Gh1RM////WzEwLCAxMl0 "Jelly – Try It Online")* [Answer] # [Japt](https://github.com/ETHproductions/japt), 60 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) ``` Ë5A $$ óKS{3N=DVNìN=KDV)q-2 DU=CgM=U)UxPÈ4C=Mg493)UCè¶r4 $$P ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=yzVBCSQkIPNLU3szTj1EVk7sTj1LRFYpcS0yCkRVPUNnTT1VKVV4UMg0Qz1NZzQ5MylVQ%2bi2cjQgJCRQ&input=WzEyLDEwXQ) I used [this program](https://tio.run/##jVRbT9RAFH5uf8VYo86Ete5CNBEEVIKERBMDRB6Eh9kysk1qd9NpsUZIEO/gBW/xURS84/1@fZjzT@SH4JlOt4v4YrJpds71O993Zjy505P@@noi/XCSDJ@WsTjpjog0dofEZBLwqD9tREJKvx7KLnuKR8Qn3WQwRDefGKn3hxOU5fawkcTowzyRukd47NWEpH6J7Hfo2uwc66W9nWuz83Rsoo2tzS5M07Fw2mXMydNlQ3g@D7CAox6oh2pZrahH6rF6op6qZ@q5eqFW1Sv1Wr1Rb9U79V59UB/VJ/VZfVFf1Tf1Xf1QP9UvmIWzMAfn4DxcgItwCS7DFZiHBbgK1@A63IBFuAm34DbcgbtwD@7DEjyAh7AMK/AIHsMTeArP4Dm8gFV4Ca/gNbyBt/AO3sMH@Aif4DN8ga/wDb7DD6fNN7i9Go8korat/jA5KSJeDYQ7xMNJQcul9t17mG25ozURCYqz9RD87iOVPWWyfTvZonPdQdlXD@OoHlCqzyxgZHqaYHA3qXQUf/e2jOUsIOfL1cncD2WRrRsOi0B4MR0Q8SHuCZlTzIOg7z/Q/ptsn6hHgns1QjNZCUexjd6MnLEtXRurYVnuDkT1pCGPt4@7w4mH2ZL0YmTsHsW@gm70H@NBIhjpJBT9rPB05J7j5fEu29IzkSl9xupmQuyEjtHIjwV1ziDqGazhlEi/9HhD0CyYadBWgVoDrGrMLQCVjQALYjqNnCwby/JPkIIFim2ZeyA8TasF5XlYjiXvb0C2Rq66h7mMKWMak2XN2PqXZRz2Q6Evz4xtD7bU2CfjCK9iDyk6Yy1Nb1VEWb9IxEkUkn/0q5T0ajTVS/WyjdQPcoRgkkskZaab6dAkLKPYYzretoxLT@jxmHruSH04s1C9GEOiESAi6oyFTsn5vTjv/G2NUQU0X9lkjoz52t9mYqxLzoaVy0BvuhQpQ4EcfDicNrMpKWnT5wUH1Uo3AMw0z0fLB28xV9JLSCI@4acZiVra7JTdKEZyUkNxipgSdEdlR6lJe1eTGIyTSaBfOcdB46maHwiS80t6SNksRBGUO7aZxojbePQe5K5d3cbXla1FjqIZNbO@Dqv4dG7F6ds7cOQ/ "C# (Visual C# Interactive Compiler) – Try It Online") to find facing pairs. This program is Japt-specific, as it filters out characters Japt doesn't use. To use, enter any characters in the input section, and it will find all valid Japt characters that face them. To include control characters in the input, input `《number》` into the input section. To include control characters in the list of facing characters, prepend `。` before the character, like `。#`. This challenge is made much more difficult by the fact that there are many characters in the ISO-8859-1 codepage (Japt's default) that are unused in Japt, and cause syntax errors if they are not part of a string. Additionally, since calls to functions must be closed with , `)`, or `¹`, many functions are off limits. The code only contains calls to 8 functions total. Here is the equivalent Javascript code: ``` U = U.m(function(D, E, F) { return (D, 5, A ).ó(function(K, S) { return (3, N = D, V, N.ì(N = K, D, V)).q("-", 2) }) }); (D, U = C.g(M = U)), U.x(function(P, X, Y, Z) { return (X, 4, C = M.g(493)), U, C.è("===".r(4), P) }) ``` As you can see, there are many assignments made to different variables, because very few variables face a function. The Cartesian product function (`ï`) is locked, since every character `ï` faces is an unprintable that results in a syntax error in Japt. A thing to note is that when values are chained together not like `DU` or `5A`, only the value at the end is used, but only if the values are not arguments to a function. The values before are essentially no-ops. ``` Ë5A $$ óKS{3N=DVNìN=KDV)q-2 Ë //Map each variable D in the input 5A //A is the variable for 10 \t$$ //Tab (a no-op) followed by $$, followed by a single space //Everything between 2 dollar signs is //injected into the transpiled JavaScript //literally. In this case, we inject nothing //Space is not a no-op in Japt, it acts like parentheses ó //Range, 0-9 //Map each in the range through the following function KS{ //An "old-style" function, taking in parameters K and S //K = current #, S = index (ignored) //Obsolete nowadays, replaced by '@','\_','È',and 'Ï' 3N=D //Assign N to D V //No-op variable NìN=KDV //Convert N to base K array, the last two variables are //ignored in the function call. Luckily, if 0 //is passed as the base, it returns base-10 digits //Though 's' is much more handy as it returns a string, //It only accepts bases 2-36 )q-2 //Join the base-K array with '-' (2 is a no-op) //Newline - assign the result of the previous to U DU=CgM=U)UxPÈ4C=Mg493)UCè¶r4 $$P C //12 g //Index into (wrapping) M=U) //U, essentially getting first element, also assign U to M DU= //Assign that to U Ux //Map everything in U to the following function, then sum PÈ //Function w/ parameters 'P','X','Y','Z' 4C=Mg493) //Assign C to M[1] (indices are wrapping) ¶r4 //Replace all "4" strings in "===" with "" UCè $$P //No. of elements in C that "===" (equals) P ``` ]
[Question] [ ## Background I have a bunch of old and grainy black-and-white images. Some of them depict vines climbing on a wall, others don't – your task is to classify them for me. ## Input and output Your input is a rectangular 2D array of bits A, given in any convenient format. It will not be empty, but it's not guaranteed to contain both 0s and 1s. The array depicts a vine if the following conditions hold: * The bottom row of A contains at least one 1. These are the roots of the vine. * Every 1 in A is connected to the bottom row by a path of 1s that only goes left, right and down (not up, and not diagonally). These paths are the branches of the vine. Your output is a consistent truthy value if the input depicts a vine, and a consistent falsy value otherwise. ## Examples This array depicts a vine: ``` 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 1 1 1 1 1 0 1 0 1 0 1 1 1 0 1 0 0 1 0 1 1 ``` This input does not depict a vine, since there's a 1 at the middle of the right border that's not connected to the roots by a branch: ``` 0 0 0 1 1 0 0 1 0 1 1 1 0 1 0 1 0 1 0 1 1 1 1 0 0 0 1 1 0 1 ``` The all-0 array never depicts a vine, but the all-1 array always does. ## Rules and scoring You can write a full program or a function. The lowest byte count wins, and standard loopholes are disallowed. ## Test cases Truthy inputs: ``` 1 0 1 1 01 11 0000 0111 1100 1001 1111 1111 1111 1111 001001 011001 010111 110101 011101 001011 1011011 1001001 1111111 0100000 0111111 1111001 1001111 1111101 0000000 0011100 0010100 0011100 0001000 1111111 0001000 0011100 0010100 0010100 ``` Falsy inputs: ``` 0 1 0 10 01 000 000 000 011 110 000 111111 000000 101011 111001 010010 001000 000010 110001 001100 111111 110101 010011 111011 000110 010111 010101 011110 001101 11000000 10110001 10011111 11110001 01100011 00110110 01101100 01100001 01111111 ``` [Answer] ## [Snails](https://github.com/feresum/PMA/blob/master/doc.md), ~~25~~ ~~19~~ 17 bytes ``` & \0z),(\1dlr)+d~ ``` [Try it online!](http://snails.tryitonline.net/#code=JgpcMHopLChcMWRscikrZH4&input=MDAwMDAwMAowMDExMTAwCjAwMTAxMDAKMDAxMTEwMAowMDAxMDAwCjExMTExMTEKMDAwMTAwMAowMDExMTAwCjAwMTAxMDAKMDAxMDEwMA) ### Explanation Snails is a 2D pattern-matching language inspired by regex, which was originally developed [for our 2D pattern matching language design challenge](https://codegolf.stackexchange.com/a/47495/8478). The `&` makes Snails try the pattern from every possible starting position and prints `0` or `1` depending on whether the pattern fails in any of them or matches in all of them. Now Snails can work with implicit parentheses, so the pattern is shorthand for the following: ``` (\0z),(\1dlr)+d~ ``` The `,` acts like a `` in regex (i.e. match zero or more times), whereas the `+` is the same as in regex (match one or more times). So we start by matching `\0z` as often as necessary, which matches a single `0` and then allows the snail to reset its direction arbitrarily with `z`. This allows zeros in the input, provided a valid vine cell can be found anywhere else. Then we match at least one `\1dlr`, which matches a single `1` and then allows the snail to reset its direction either down, left or right. Note that if the cell we've started at contains a `1` then we're only matching this part. It basically allows the snail to traverse a vine from a branch down to the roots. Finally, we need to ensure that we did reach the ground by looking for an out-of-bounds cell (`~`) below (`d`). [Answer] ## JavaScript (ES6), 135 bytes ``` s=>s.replace(/^[^1]\n/,``).split` `.map(s=>+`0b${s}`).reverse(g=(n,m,o=(m<<1\|m\|m>>1)&n)=>n-m?o-m&&g(n,o):n).reduce((m,n,i)=>g(n,n&m)) ``` Note: Due to limitations of integer type, only works for vines of up to 31 characters wide. Explanation: Each row is bitwise ANDed with the adjacent row to determine the connection points, and then the `g` function is used to recursively expand the row horizontally until it can expand no more. For instance, if two adjacent rows are `1110111` and `1011100` then the connection points are `1010100` and this is then expanded to `1110110` and then `1110111` which then finds that the row is connected. If the `g` function fails then it returns zero which causes all subsequent `g` functions to fail too, and the result is then falsy. If the `g` function succeeds it returns the new row which is then propagated through the `reduce` to test the next row. ``` s=>s.replace(/^[^1]\n/,``) Remove irrelevant leading "blank" rows .split`\n` Split into lines .map(s=>+`0b${s}`) Convert into binary .reverse( Process from bottom to top g=(n,m,o=(m<<1\|m\|m>>1)&n)=> Expand row horizontally n-m?o-m&&g(n,o):n) Check whether rows are connected .reduce((m,n,i)=>g(n,n&m)) Check all rows ``` [Answer] # Python 2, 254 bytes No libraries ``` def f(A,r=0,c=-1): B=A[r];R=len(A)-1;C=len(B);i=1 in A[R] if c<0: for j in range(RC+C): if A[j/C][j%C]:i&=f(A,j/C,j%C) return i&1 _=B[c];B[c]=0;i=_&(r==R) if _: if c>0:i\|=f(A,r,c-1) if r<R:i\|=f(A,r+1,c) if c<C-1:i\|=f(A,r,c+1) B[c]=_;return i ``` Note that the second and third level indents are formed with tabs in the byte count. [Try it online](https://repl.it/CYeq/2) [Answer] # Wolfram - 254 Spend some time making this work, so I'll just leave it here: ``` f[s_]:=( v=Characters@StringSplit@s; {h,w}=Dimensions@v; g=GridGraph@{w,h}; r=First/@Position[Flatten@v,"0"]; g=VertexDelete[Graph[VertexList@g, EdgeList@g/.x_y_/;Abs[x-y]>1yx],r]; v=VertexList@g; v≠{}∧v~Complement~VertexOutComponent[g,Select[v,#>w h-w&]]{} ) ``` Basically I construct a grid graph with directed edges pointing up, remove vertices that correspond to 0s, check that bottom vertex components contain all vertices. Ridiculous, I know... [Answer] ## Python + NumPy ~~204~~ ~~202~~ 195 Bytes ``` from numpy import* def f(A): r,c=A.shape z,s=zeros((r,1)),array([0,2,c+3]) B=hstack((z,A,z)).flat for i in range(1,(r-1)*(c+2)): if B[i]and not any(B[s]):return 1<0 s+=1 return any(B[i:]) ``` Expects `A` to be a 2D numpy array. Takes the matrix, pads zero columns left and right and flattens the matrix. `s` is a stencil that points to the left, right and lower element. The loop checks each element except the last line if it is `1` and at least one of its stencil is `1`, returns `False` otherwise. Afterwards, check if the last line contains any `1`. Two testcases for you: ``` I1 = '001001\n011001\n010111\n110101\n011101\n001011' A1 = array([int(c) for c in I1.replace('\n','')]).reshape(6,6) print f(A1) #True I2 = '001100\n111111\n110101\n010011\n111011' A2 = array([int(c) for c in I2.replace('\n','')]).reshape(5,6) print f(A2) #False ``` Edit1: `1<0` is shorter than `False` Edit2: `flat` is a fine alternative to `flatten()` and using tabulators for the second intendation in the loop ]
[Question] [ In the ASCII art world, there is water, hash walls and letter mechanisms. You are in a room made up of hash walls (`#` signs): ``` ####### # # # # # # # ### # # # ####### ``` You install an S water source (`S` sign) and an E water tank (`E` sign) which can receive water from any direction, but you only have one S source and one E tank. ``` ####### # S # # # # # # ### # # E # ####### ``` So you have to select wisely where to place the source. That's where you pull off your [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") skills. ## The task You get an input consisting of a string representing a room with the source and the tank: ``` ####### # S # # # # # # ### # # E # ####### ``` You have to find out if the water ultimately reaches the tank. The water flows down, if possible, else to the left and right, if possible. The water doesn't accumulate because it doesn't go up. So, for the above input, the result is: ``` ####### # * # # * # #****# ##### #O# ####### ``` The water happily reaches the tank, so you must output a truthy value. But if the water doesn't reach the tank: ``` ####### #S # # # # E # # ### # # # ####### ####### # # #* # #* X # #### # #***# ####### ``` Then you must output a falsy value. Write a program to decide whether the water ultimately reaches the tank. Your code should be as short as possible. ## Assumptions Assume that the input is always valid (the entire room is an enclosed rectangular region with the S and E). * Assume there is only one room provided as input. ## Test Cases Your program should return a truthy value for the following test cases: ``` ####### # S # # # # # # ### # # E # ####### ####### # S # # # # E # # # # # ####### ####### # # # # # SE # # ### # # # ####### ############################################### # S # # # # # # # # ############### # # # # ################## ################## # # # # # # ##### # # E # ############################################### ####### # S # # # # # # ### # # # # ### ### ## E ## # # ####### ``` But a falsy value for the following test cases: ``` ####### #S # # # # E # # ### # # # ####### ####### # # # SE # # # # # # # ####### ####### # # # E # # # # S # # # ####### #################################### # # # # # # #S # E# #################################### ``` The second to last room in the True category and the last room in the False category were shamelessly ~~stolen~~ borrowed from ~~[Koth: Jump and Run](http://meta.codegolf.stackexchange.com/a/8575/48538)~~ by [Manu](https://codegolf.stackexchange.com/users/15080/manu) (who deleted the sandbox post). The last room in the True category is from [Martin Buttner's answer in Retina](https://codegolf.stackexchange.com/a/74468/48538). [Answer] # [Snails](https://github.com/feresum/PMA), 20 bytes ``` \S{d(=\#n)?^#},!(t\E ``` Prints `0` for the falsey value and `1` for the truthy value. [Try it online!](http://snails.tryitonline.net/#code=XFN7ZCg9XCNuKT9eI30sISh0XEU&input=IyMjIyMjIwojICBTICAjCiMgICAgICMKIyAgICAgIwojICMjIyAjCiMgIEUgICMKIyMjIyMjIw) * `\S` matches `S` at the start * `d` sets direction to down * `{...},` matches the stuff in braces 0 or more times * `=\#` is an assertion which succeeds if there is a `#` char ahead of the snail, but does not move it * `n` turns 90 degrees in either direction * `(...)?` matches the pattern in parentheses 0 or 1 times * `\ ` matches a space and moves the snail onto it * `!(...` is a negative assertion * `t` teleports to any unmatched square in the grid * `\E` matches `E` [Answer] ## [Slip](https://github.com/Sp3000/Slip/wiki), 20 + 2 = 22 bytes ``` S>( ^4\|^4(?\|`#)^T)E ``` So Slip's still as broken as ever, but for once this was a challenge it could actually do. It was never really designed to be that golfy though, so it'll never beat Snails at anything :P Needs the `r` flag (no repeating cells) to terminate. [Try it online](https://slip-online.herokuapp.com/?code=S%3E%28%20%5E4%7C%5E4%28%3F%7C%60%23%29%5ET%29%2aE&input=%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20S%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%20%20%20%20%20%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%23%23%23%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20E%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23&config=r). Output is the path taken for truthy, empty for falsy. ``` S Match S > Rotate pointer downward ( Either... <space>^4 Match a space and point downwards \| or ^4 Point downwards (?\|`#) Match # below then reset pointer ^T Either turn left or right ) ... 0+ times E Match E ``` [Answer] ## [Retina](https://github.com/mbuettner/retina/), 87 bytes Byte count assumes ISO 8859-1 encoding. ``` +mT`E `S`(?<=^(?(1)!)(?<-1>.)S.¶(.))[E ]\|.?S(?=(.)¶.#(?<-2>.)(?(2)!)$)[E ]? M`E 0 ``` [Try it online!](http://retina.tryitonline.net/#code=K21UYEUgYFNgKD88PV4oPygxKSEpKD88LTE-LikqUy4qwrYoLikqKVtFIF18Lj9TKD89KC4pKsK2LiojKD88LTI-LikqKD8oMikhKSQpW0UgXT8KTWBFCjA&input=IyMjIyMjIwojICBTICAjCiMgICAgICMKIyAgICAgIwojICMjIyAjCiMgICAjICMKIyMjICMjIwojIyBFICMjCiMgICAgICMKIyMjIyMjIw) As much as 2D string processing is possible in Retina (or .NET regex in general), it's not exactly concise... ### Explanation ``` +mT`E `S`(?<=^(?(1)!)(?<-1>.)S.¶(.))[E ]\|.?S(?=(.)¶.#(?<-2>.)(?(2)!)$)[E ]? ``` This is a flood-fill which marks all the cells that are reached by water with `S`. It does so by matching the characters that can be reached and then transliterating them to `S` with `T`-mode. This flood-fill goes through both spaces and `E`. The `+` at the beginning repeats this until the output stops changing. As for the actual regex is contains two separate cases: ``` (?<=^(?(1)!)(?<-1>.)S.¶(.))[E ] ``` This matches a space or `E` which is exactly one cell below an `S`. The vertical matching is done by counting the prefix on the current line using [balancing groups](https://stackoverflow.com/a/17004406/1633117) so we can ensure that the horizontal position is the same. This one takes care of falling water. ``` .?S(?=(.)¶.#(?<-2>.)(?(2)!)$)[E ]? ``` This is very similar: it matches an `S` and if available the character before and after it, provided that the character directly beneath the `S` is a `#`. This takes care of water spreading along the ground. When we're done it's very easy to determine if the water reached `E`. If it did, then `E` has been removed from the string in the flood-fill, and if not the `E` is still there. So let's count the number of `E`s: ``` M`E ``` But now that's `0` (which I'd consider falsy) for truthy test cases and `1` (which I'd consider truthy) for falsy test cases. We can invert this very easily by counting the number of `0`s in this result: ``` 0 ``` Done. ]
[Question] [ # Background OEIS sequence [A272573](https://oeis.org/A272573) describes a spiral on a hexagonal grid as follows: > > Start a spiral of numbers on a hexagonal tiling, with the initial hexagon as a(1) = 1. a(n) is the smallest positive integer not equal to or previously adjacent to its neighbors. > > > The sequence begins ``` 1, 2, 3, 4, 5, 6, 7, 4, 6, 8, 5, 9, 8, 10, 2, 11, ... ``` Here's an illustration of the spiral pattern: [![enter image description here](https://i.stack.imgur.com/gjB9D.png)](https://i.stack.imgur.com/gjB9D.png) * `a(11) != 1` because then `3` and `1` would be adjacent in two places. * `a(11) != 2` because then `3` and `2` would be adjacent in two places. * `a(11) != 3` because then `3` would be adjacent to itself. * `a(11) != 4` because then `3` and `4` would be adjacent in two places. * Therefore `a(11) = 5`. # Challenge The challenge is to write a program that computes [A272573](https://oeis.org/A272573). This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code wins. [Answer] # JavaScript (ES6), ~~267 .. 206~~ 199 bytes Returns an array containing the \$N\$ first terms of the sequence. ``` n=>(F=v=>++i<n?F([...v,(A=N[i]=[1,!j++\|\|d+1,j%L?d:(j%=L6)?++d:L++&&d++].map(k=>N[k=i-k].push(i)&&k),g=k=>v[E='every']((V,x)=>V-k\|N[x][E](y=>A[E](z=>v[y]-v[z])))?k:g(-~k))()]):v)([L=1],N=[[i=j=d=0]]) ``` [Try it online!](https://tio.run/##FcqxboMwEIDhV2mHwF1tLBiaAeVAGZIJMWaxbkAxobYTQKG1QoT66rSZ/uH7XROa6Xy343fSD6ZdL7T2VMCRAhVC2F1fHkErpYKEPdXaMulMvjshlsWITLpNVZoc3Iaqjy2WQpi8EiKKjBCsbs0Inopae7KJZzX@TF9gMYo8yo7@JegDxW1o73PMACf5QCpOiV9q/WB9YJip2L/6fK0zJ0E/GRFLn3eQ/HpEQMY8IOiKMpY1aW3JkaGUGdfz0E/DtVXXoYMLfKYpKjfYHmL5FiOufw "JavaScript (Node.js) – Try It Online") ## How? ### Definitions By convention, we will call corner-cell* a cell that has only one edge in common with the previous layer of the spiral and *side-cell* a cell that has two edges in common with the previous layer. As [suggested](https://chat.stackexchange.com/transcript/message/48051895#48051895) by Ourous, we can also think of them as order-1 cells and order-2 cells, respectively. Corner-cells are shown in yellow below. All other cells are side-cells (except the center cell which is a special case). [![cell types](https://i.stack.imgur.com/3NoTJ.png)](https://i.stack.imgur.com/3NoTJ.png) ### About cell neighbors We don't really need to keep track of the coordinates of the cells on the grid. The only thing that we need to know is the list of neighbor cells for each cell in the spiral at any given time. In the following diagrams, neighbors in the previous layer are shown in light shade and additional neighbors in the current layer in darker shade. A cell has 2 neighbors among the previous cells if: * it's the first side-cell of a new layer (like 8) * or it's a corner-cell, but not the last one of the layer (like 9) [![2 neighbors](https://i.stack.imgur.com/kvd93.png)](https://i.stack.imgur.com/kvd93.png) A cell has 3 neighbors among the previous cells if: * it's a side-cell, but not the first one of the layer (like 10) * or it's the last corner-cell of the current layer (like 19) [![3 neighbors](https://i.stack.imgur.com/fh0UK.png)](https://i.stack.imgur.com/fh0UK.png) ### Implementation of cell neighbors The index of the current cell (starting at \$1\$) is stored in \$i\$. The list of neighbors of a cell \$n\$ is stored in \$A[n]\$. For obscure golfing reasons, we first compute the opposite offsets of the neighbors. For instance, \$1\$ means \$-1\$, which means the previous cell. ``` [ // 1, // the previous cell is always a neighbor of the current cell !j++ \|\| d + 1, // if this is not the first cell of the layer, the cell at -(d + 1) // is a neighbor (otherwise, we insert 1 twice; doing it that way // saves bytes and having duplicate neighbors is not a problem) j % L ? // if this is a side-cell: d // the cell at -d is a neighbor : // else (corner-cell): (j %= L * 6) ? // if this is not the last cell: ++d // insert the dummy duplicate neighbor at -(d + 1); increment d : // else (last cell): L++ && d++ // the cell at -d is a neighbor; increment L; increment d ] // ``` In the above code: * \$L\$ is the index of the current layer, starting at \$1\$ (and not counting the center cell). * \$j\$ is the index of the current cell within the current layer, going from \$1\$ to \$6\times L\$. * \$d\$ is the distance of the current cell to those of the previous layer. It is incremented each time we go through a corner cell. We then process a `map()` loop which converts the offsets \$k\$ into indices (\$i-k\$) and push the current cell as a new neighbor for all neighbor cells, to enforce neighborhood symmetry. ``` .map(k => N[k = i - k].push(i) && k ) ``` ### Finding the next term of the sequence Now that we have an up-to-date list of neighbors for all cells, we can finally compute the next term \$k\$ of the sequence, using another recursive helper function. The value of a cell \$n\$ is stored in \$v[n]\$. ``` ( g = // g = recursive function taking k => // the candidate value k v.every((V, x) => // for each previous cell of value V at position x, make sure that: V - k // V is not equal to k \| // OR N[x].every(y => // for each neighbor y of x: A.every(z => // for each neighbor z of the current cell: v[y] - v[z] // the value of y is not equal to the value of z ) // end ) // end ) // end ? // if the above conditions are fulfilled: k // stop recursion and return k : // else: g(-~k) // try again with k + 1 )() // initial call to g with k undefined (this will cause V - k to be // evaluated as NaN and force the 1st iteration to fail) ``` [Answer] # [Clean](https://github.com/Ourous/curated-clean-linux), ~~284~~ ~~279~~ ~~272~~ 262 bytes ``` import StdEnv l=[0,-1,-1,0,1,1] c(u,v)(p,q)=(u-p)^2+(v-q)^2<2\|\|(u-p)(q-v)==1 $[h:t]m=hd[[e: $t[(h,e):m]]\\e<-[1..]\|and[e<>j\\(u,v)<-m\|c h u,(p,q)<-m\|q==v,(i,j)<-m\|c p i]] ``` # ``` $(scan(\(a,b)(u,v)=(a-u,b-v))(0,0)[(i,j)\\n<-[1..],i<-[1,1:l]&j<-l,_<-[max(~j<<i)1..n]])[] ``` [Try it online!](https://tio.run/##NVDBTsMwDL33K3KYkAPO1O5YJZzggMQBacckoJBmNFWStVtbgVTx6ZSuDMmS/Wy/9yzb4Eya47EagiPR@DT72B5PPdn31WMasyBkjqy4RI4FFjqzMOBIocWOChhYS193dzCybsl8N01r6xY6NlIhimwj67LXUdSVlK4km15CjY6WUWulHGey2G71ZFIlHb9vlFrFOYuTJTUZcLW5wE6IEcFjcx22xGs9n103uGQdEWQDZ2sSKDD4TlcVAYYN@L4cQiHHnMqVrlS6uqK/FFiUQd80nAV8W3A0n/DdcO7pspK0plJn@94sDxHk323@sYdgPs4ze3qeH76Sid7@gZdg@sPxFH8B "Clean – Try It Online") Generates the sequence forever. Hexagon Mapping* Most of the code goes into mapping hexagons uniquely to `(x,y)` coordinates so that there's a single, simple function to determine adjacency which holds for all point mappings. The mapped points look like this: ``` --- --- < 2,-2> --- x-axis ___.X' --- < 1,-2> === < 2,-1> --- /__.X' < 0,-2> === < 1,-1> === < 2, 0>' === < 0,-1> === < 1, 0> === <-1,-1> === < 0, 0> === < 1, 1> === <-1, 0> === < 0, 1> === <-2, 0> === <-1, 1> === < 0, 2>.__ --- <-2, 1> === <-1, 2> --- \ 'Y.___ --- <-2, 2> --- y-axis 'Y. --- ``` From there, determining adjacency is trivial, and occurs when one of: * `x1 == x2` and `abs(y1-y2) == 1` * `y1 == y2` and `abs(x1-x2) == 1` * `y1 == y2 - 1` and `x2 == x1 - 1` * `y1 == y2 + 1` and `x2 == x1 + 1` * `x1 == x2` and `y1 == y2` Point Generation Notice that when traversing the hexagon in a spiral the differences recur for each layer `n`: 1. `n` steps of `(1,0)` 2. `n-1` steps of `(1,-1)` 3. `n` steps of `(0,-1)` 4. `n` steps of `(-1,0)` 5. `n` steps of `(-1,1)` 6. `n` steps of `(0,1)` This generates the points in the right order by taking sums of prefixes of this sequence: ``` scan(\(a,b)(u,v)=(a-u,b-v))(0,0)[(i,j)\\n<-[1..],i<-[1,1:l]&j<-l,_<-[max(~j<<i)1..n]] ``` Bringing it Together The code that actually finds the sequence from the question is just: ``` $[h:t]m=hd[[e: $t[(h,e):m]]\\e<-[1..]\|and[e<>j\\(u,v)<-m\|c h u,(p,q)<-m\|q==v,(i,j)<-m\|c p i]] ``` Which in turn is mostly filtering by `and[r<>j\\(u,v)<-m\|c h u,(p,q)<-m\|q==v,(i,j)<-m\|c p i]` This filter takes points from `m` (the list of already-mapped points) by: * Ignoring natural numbers that are equal to any `j` * For every `(i,j)` where `i` is adjacent to `p` * For every `(p,q)` where the value `q` is equal to `v` * For every `(u,v)` where `u` is adjacent to the current point ]
[Question] [ Introduction This is one is pretty straightforward. We will be drawing a snake in ascii. This was inspired by that old snake game where you have to collect the fruit and you continuously grow. Definition Given a positive integer N that represents the snake's length, draw a snake so that it has a body of n plus a head and a tail. Parts: * head: `<, >, ^, v` * tail: `@` * vertical: `\|` * horizonal: `-` All corners should be satisfied with a `\` or `/` respectively. Unless the head ends on a corner in which case the head `<, >, ^, v` takes priority in the direction the snake is curled. i.e. for the length 1 example, it is turned counter clockwise and so the head is turned that way. For a clockwise solution it would be to the right `>`. The snake must start in the middle with its tail but it may go outwards in any direction you choose either clockwise or counter-clockwise. It must also wrap tightly around itself as it expands outwards in a circular fashion. Example ``` /--\ \|/\\| \|\|@\| \|\-/ \---> ``` Where the `@` is the tail and starting position. As seen above the tail starts in the middle, goes up to the left in a counter-clockwise rotation outward. Here the length is `19` plus a tail and a head. As another example, here is length `1`: ``` <\ @ ``` Winning This is code-golf so the answer that is submitted with the smallest number of bytes wins, with time to be used as a tie breaker. Have fun! [Answer] # [MATL](http://github.com/lmendo/MATL), ~~85~~ 83 bytes And I thought that having a `spiral` builtin would make for short code... ``` Oli2+XH:UQXItH:+XJh(YsXKoQ3I(4J(5l(H:)0HX^XkU(6H(3M1YL3X!P)'\|-\/@' '<v>^'KHq))h0hw) ``` [Try it online!](http://matl.tryitonline.net/#code=T2xpMitYSDpVUVhJdEg6K1hKaChZc1hLb1EzSSg0Sig1bChIOikwSFheWGtVKDZIKDNNMVlMM1ghUCknfC1cL0AnICc8dj5eJ0tIcSkpaDBodyk&input=MTk) ### Explanation Let N denote the input. We will create a vector of length `ceil(sqrt(N+2))^2`, that is, the smallest perfect square that equals or exceeds N+2. This vector will be filled with numeric values, rolled into a spiral (that's why its length needs to be a perfect square), and then the numeric values will be replaced by characters. Let n denote each step starting from 1 at the center of the spiral. The steps where the snake turns are given by n2+1 (that is: 2, 5, 10, ...) for `\` symbols and n2+n+1 (that is: 3, 7, 13, ...) for `/`. The steps between a `\` and a `/` should be `-`, and those between a `/` and a `\` should be `\|`. The vector is created such that it contains `1` at the turn points (2,3,5,7,10,13...) and `0` at the rest. The parity of the cumulative sum tells if each entry should be a `-` or a `\|`. Adding 1 to this result we get a vector containing `1` (for `\|`) or `2` (for `-`). But this makes the turn points themselves become `1` or `2` too. So the turn points, whose positions we know, are overwritten: positions n2+1 are filled with `3` and positions n2+n+1 are filled with `4`. The tail and head are also special cases: the first element of the vector (tail) is set to `5`, and the element with index N+2 (head) is set to `6`. Finally, elements with indices exceeding N+2 are set to `0`. Taking input N=19 as an example, we now have a vector with length 25: ``` 5 3 4 1 3 2 4 1 1 3 2 2 4 1 1 1 3 2 2 2 6 0 0 0 0 ``` We need to roll this vector into a spiral. For this we use a builtin function that generates a spiral matrix, followed by a reflection and a transposition to produce: ``` 13 12 11 10 25 14 3 2 9 24 15 4 1 8 23 16 5 6 7 22 17 18 19 20 21 ``` Indexing the vector with the matrix gives ``` 4 2 2 3 0 1 4 3 1 0 1 1 5 1 0 1 3 2 4 0 3 2 2 2 6 ``` where `0` corresponds to space, `1` corresponds to `\|`, `2`to `-`, `3` to `\`, `4` to `/`, `5` to `@`, and `6` to the head. To know which of the four characters `^`, `<`, `v`, or `>` the head should have, we use the cumulative sum of turn points that we previously computed. Specifically, the second-last value of this cumulative sum (i.e. the N+1-th value) modulo 4 tells us which character should be used for the head. We take the second-last value of the cumulative sum, not the last, because of the requirement "if the head ends on a corner the head `<`, `>`, `^`, `v` takes priority in the direction the snake is curled". For the N=19 example the head is `>`. Now we can build a string containing all the snake characters, including the appropriate character for the head at the sixth position: `'\|-\/@> '`. We then index this string with the above matrix (indexing is 1-based and modular, so space goes last), which gives ``` /--\ \|/\\| \|\|@\| \|\-/ \---> ``` [Answer] # Python 2, ~~250~~ ~~233~~ 191 bytes ``` n=input() l=[''], a=x=0 b='@' while a<=n:x+=1;l+=b,;l=zip(l[::-1]);m=x%2;b='\/'[m]+x/2'-\|'[m];k=len(b);a+=k l+=b[:n-a]+'>v'[m]+' '(k-n+a-1), if m:l=zip(l[::-1]) for i in l:print''.join(i) ``` * Saved 39 bytes thanks to @JonathanAllan [repl.it](https://repl.it/DoE6/2) Draw the snake by rotating the entire snake 90º clockwise and adding the bottom segment, this way the snake will always be anticlockwise. The new segment will always start with `\` and have `-` as body for even sides and `/` `-` for odd sides. The segments sizes (without corners) are `0`,`1`,`1`,`2`,`2`,`3`... which is `floor(side/2)`. If the segment is the last, it remove the excess characters, add the head and complete with spaces. ``` desired_size=input() snake=[['']] snake_size=side=0 new_segment='@' while snake_size<=desired_size: side+=1 snake+=[new_segment] snake=zip(snake[::-1]) odd_side=side%2 new_segment='\/'[odd_side]+side/2'-\|'[odd_side] snake_size+=len(new_segment) diff=desired_size-snake_size snake+=[new_segment[:diff]+'>v'[odd_side]+' '(len(new_segment)-diff-1)] if odd_side: snake=zip(snake[::-1]) for line in snake:print ''.join(line) ``` [Answer] # JavaScript (ES6), 193 ~~201 203 215 220 224~~ Edit saved 4 bytes thx @Arnauld Edit2 changed logic, not storing the current increments for x and y, just get them from the current direction Edit3 having saved a few bytes, I decided to use them for a better management of the blank space Edit4 8 bytes saved not following exactly the examples about the head direction - like other answers The current version works with Chrome, Firefox and MS Edge ~~This answer gives some trailing and leading space (and blank lines).~~ ``` n=>(t=>{for(x=y=-~Math.sqrt(++n)>>1,g=[i=t];(g[y]=g[y]\|\|Array(x).fill` `)[x]='^<v>\|-/\\@'[t?n?i-t?4+t%2:x-y?7:6:t%4:8],n--;i=i>1?i-2:++t)d=t&2,t&1?x+=d-1:y+=d-1})(0)\|\|g.map(x=>x.join``).join` ` ``` Slightly less golfed ``` n=> { g = [], // to save a few bytes, change line below (adds a lot of spaces) // w = ++n, w = -~Math.sqrt(++n) x = y = w>>1, s=c=>(g[y] = g[y] \|\| Array(x).fill(' '))[x] = c, // function to set char in position s('@'); // place tail for ( i = t = 0; // t increases at each turn, t%4 is the current direction n--; i = i > 0 ? i - 2 : t++ // side length increases every 2 turns ) d = t & 2, t & 1 ? x += d-1: y += d-1 s(!n ? '^<v>' [t % 4] // head : '\|-/\\' [i > 0 ? t % 2 : x-y ? 3 : 2]) // body return g.map(x=>x.join``).join`\n` } ``` ``` f= n=>(t=>{for(x=y=-~Math.sqrt(++n)>>1,g=[i=t];(g[y]=g[y]\|\|Array(x).fill` `)[x]='^<v>\|-/\\@'[t?n?i-t?4+t%2:x-y?7:6:t%4:8],n--;i=i>1?i-2:++t)d=t&2,t&1?x+=d-1:y+=d-1})(0)\|\|g.map(x=>x.join``).join` ` function update() { O.textContent=f(+I.value); } update() ``` ``` <input type=number id=I value=19 oninput='update()' onkeyup='update() /* stupid MS browser, no oninput for up/down keys /'> <pre id=O> ``` [Answer] ## JavaScript (ES7), 200 bytes ``` (n,s=(n4+1)*.5\|0,i=+`1201`[s%4],d=i=>`-`.repeat(i))=>[...Array(s-2>>2)].reduce(s=>`/-${d(i)}\\ ${s.replace(/^\|$/gm,`\|`)} \|\\${d(i,i+=2)}/`,[`/\\ \|@`,`/-\\ \|@/`,`@`,`/@`][s%4])+` \\${d(n-(ss>>2))}>` ``` ES6 version for ease of testing: ``` f=(n,s=Math.sqrt((n4+1))\|0,i=+`1201`[s%4],d=i=>`-`.repeat(i))=>[...Array(s-2>>2)].reduce(s=>`/-${d(i)}\\ ${s.replace(/^\|$/gm,`\|`)} \|\\${d(i,i+=2)}/`,[`/\\ \|@`,`/-\\ \|@/`,`@`,`/@`][s%4])+` \\${d(n-(ss>>2))}>`; ``` ``` <input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o> ``` [Answer] # Perl, ~~111~~ 110 bytes Includes +1 for `-p` Give size on STDIN `snake.pl`: ``` #!/usr/bin/perl -p s%> %->%+s%\^ %/>%\|\|s/ / /g+s%.%!s/.$//mg<//&&join"",//g,$/%seg+s/ /^/+y%/\\\|>-%\\/\-\|%for($\="/ \@ ")x$_}{ ``` [Answer] ## Batch, 563 bytes ``` @echo off if %1==1 echo /@&echo v&exit/b set w=1 :l set/ah=w,a=ww+w if %a% gtr %1 goto g set/aw+=1,a=ww if %a% leq %1 goto l :g call:d set r=/%r%\ set/ae=h%%2,w=%1-hw+2 for /l %%i in (1,1,%h%)do call:r call:d echo \%r%^> exit/b :d set r= for /l %%i in (3,1,%w%)do call set r=%%r%%- exit/b :r echo %r:!=^\|% if %e%==0 set r=%r:@!=\/% set r=%r:@/=\/% set r=%r:!\=\-% set r=%r:/@=\/% set r=%r:/!=-/% set r=%r:@!=\/% set r=%r:/\=!@% set r=%r:/-=!/% if %e%==1 set r=%r:/\=@!% set r=%r:/\=@/% set r=%r:-\=\!% if %e%==1 set r=%r:/\=/@% ``` Explanation: Special-cases 1 as the rest of the code requires a snake width of at least two. Next, calculates the largest quarter square (either an exact square or a rectangle 1 wider than it is high) whose area is less than the length of the snake. The snake will be coiled into this rectangle starting at the bottom left corner and ending with the tail in the middle, and the remaining length will run under the bottom of the rectangle. The rectangle is actually generated from simple string replacements; most of the time each line is generated from the previous line by moving the diagonals 1 step, but obviously the tail also has to be dealt with, and there are slight differences depending on whether the height of the rectangle is even or odd. [Answer] Python 2.7, A WHOPPING 1230 bytes* I am new to python and code golf but I felt I had to answer my own question and sulk away in shame after the fact. A lot of fun working on it though! ``` def s(n): x = [] l = 0 if n % 2 == 1: l = n else: l = n + 1 if l < 3: l = 3 y = [] matrix = [[' ' for x in range(l)] for y in range(l)] slash = '\\' newx = l/2 newy = l/2 matrix[l/2][l/2] = '@' newx = newx-1 matrix[newx][newy] = slash #newx = newx-1 dir = 'West' for i in range(0, n-1): newx = xloc(newx, dir) newy = yloc(newy, dir) sdir = dir dir = cd(matrix, newx, newy, dir) edir = dir if (sdir == 'West' or sdir == 'East') and sdir != edir: matrix[newx][newy] = '/' else: if (sdir == 'North' or sdir == 'South') and sdir != edir: matrix[newx][newy] = '\\' else: if dir == 'East' or dir == 'West': matrix[newx][newy] = '-' else: matrix[newx][newy] = '\|' newx = xloc(newx, dir) newy = yloc(newy, dir) sdir = dir dir = cd(matrix, newx, newy, dir) edir = dir print 'eDir: ' + dir if dir == 'North': matrix[newx][newy] = '^' if dir == 'South': matrix[newx][newy] = 'v' if dir == 'East': matrix[newx][newy] = '>' if dir == 'West': matrix[newx][newy] = '<' p(matrix, l) def cd(matrix, x, y, dir): if dir == 'North': if matrix[x][y-1] == ' ': return 'West' if dir == 'West': if matrix[x+1][y] == ' ': return 'South' if dir == 'South': if matrix[x][y+1] == ' ': return 'East' if dir == 'East': if matrix[x-1][y] == ' ': return 'North' return dir def p(a, n): for i in range(0, n): for k in range(0, n): print a[i][k], print ' ' def xloc(x, dir): if dir == 'North': return x -1 if dir == 'West': return x if dir == 'East': return x if dir == 'South': return x + 1 def yloc(y, dir): if dir == 'North': return y if dir == 'West': return y - 1 if dir == 'East': return y + 1 if dir == 'South': return y s(25) ``` <https://repl.it/Dpoy> ]
[Question] [ Consider the following alphabetically sorted list of words: ``` balderdash ballet balloonfish balloonist ballot brooding broom ``` All of the words start with `b`, and the first 5 start with `bal`. If we just look at the first 2 words: ``` balderdash ballet ``` we could write instead: ``` balderdash +let ``` where the `' '` is used where a word shares a prefix character with the previous word; except for the `'+'` character which indicates the LAST character where the second word shares a prefix with the previous word. This is a sort of ['trie'](https://en.wikipedia.org/wiki/Trie) visualization: the parent is '`bal`', and has 2 descendants: `'derdash'` and `'let'`. With a longer list, such as: ``` balderdash ballet brooding ``` we can additionally use the pipe character `'\|'` to make it clearer where the shared prefix ends, as follows: ``` balderdash \| +let +rooding ``` and the equivalent tree would have a root of `'b'` having two children: the subtree having root `'al'` and and its two children `'derdash'` and `'let'`; and `'rooding'`. If we apply this strategy to our original list, ``` balderdash ballet balloonfish balloonist ballot brooding broom ``` we get output that looks like: ``` balderdash \| +let \| +oonfish \| \| +ist \| +t +rooding +m ``` If two consecutive words in the list have no shared prefix, no special characters are substituted; e.g. for the list: ``` broom brood crude crumb ``` we want the output: ``` broom +d crude +mb ``` ## Input The words in the input will be made up of only alphanumerics (no spaces or punctuation); this may be in the form of a list of strings, a single string, or any other reasonable approach, as long as you specify your chosen format. No two consecutive words will be the same. The list will be alphabetically sorted. ## Output Your output can contain trailing whitespace per line or in total, but no leading whitespace. A list of strings or similar would also be acceptable. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"); the shortest code in each language retains bragging rights. The usual prohibitions against loopholes apply. ## Test Cases ``` Input: apogee apology app apple applique apply apt Output: apogee \|+logy +p \|+le \| +ique \| +y +t Input: balderdash ballet balloonfish balloonist ballot brooding broom donald donatella donna dont dumb Output: balderdash \| +let \| +oonfish \| \| +ist \| +t +rooding +m donald \| \|+tella \| +na \| +t +umb ``` [Answer] # [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~58~~ 57 bytes ``` ^((.).)(?<=\b\1.¶\1) $.2$* + m)+`^(.) (.¶\1[+\|]) $1\|$2 ``` [Try it online!](https://tio.run/##LYw7DsMgEER7TuGCgo@EhOtEOUgcZKwlCRIfCZPO58oBcjG8Jm72Pc2Mtrjqk23NMKYEV5zdLlczaSV@30lzQtVIxSBJ5HI2x2Jg/@outwfWeqNja4sN4ArY9U1Qg6sdOaenPyN0v54xouQMPr26RAI54YOO6kKwh6V@K4FPXHY "Retina 0.8.2 – Try It Online") Link includes one test case. Edit: Saved 1 byte thanks to @FryAmTheEggman pointing out that I overlooked a switch from `\b` to `^` made possible by the `m)`. Explanation: ``` m) ``` Turn on per-line `^` for the whole program. ``` ^((.).)(?<=^\1.¶\1) $.2$* + ``` For each word, try to match as much as possible from the beginning of the previous word. Change the match to spaces, except the last character, which becomes a `+`. ``` +`^(.) (.¶\1[+\|]) $1\|$2 ``` Repeatedly replace all spaces immediately above `+`s or `\|`s with `\|`s. [Answer] # JavaScript (ES6), 128 bytes Expects and returns a list of lists of characters. ``` a=>a.map((w,y)=>a[~y]=w.map(m=(c,x)=>(p=a[y-1]\|\|0,m\|=c!=p[x])?c:p[x+1]==w[x+1]?' ':(g=y=>a[y][x]<1?g(y+1,a[y][x]='\|'):'+')(-y))) ``` [Try it online!](https://tio.run/##jZDBboQgFEX3fgV1A0QldTsp44dYFoygdYJAxalDYvrrlppZKJMmXT3Oyc3lwZV/cdeMvZ0KbYRcW7pyeuZk4BahOfc4QP3tGZ03NVDU5PcgkaW89kXJluU1HxbavFBb3xmumlOYWckonbdZQQBPqKP@t8izkHkrqw75rMwfTOEC8QlmEKPCY4zXxmhnlCTKdKhFdQJATQhJuTWdlCnLdyJE/MHYIykZcf95i9WxYEpZwvD2WAfoGThyNb1GEGL8OL1riEEGtpkkfyx74UrIUXD3sWsPUskpEsbotn@KBdu7p@hBjMaIXneRGnYsjA5rRGKSSvGj0xHvrxG34fKvL8HrDw "JavaScript (Node.js) – Try It Online") ### How? Spaces and `+`'s can be inserted by walking through the first to the last word in order, but `\|`'s can only be inserted a posteriori once a `+` has been identified. This could be achieved by doing two distinct passes, but instead we save a pointer to each modified entry in `a[~y]` so that it can later be updated again within the same `map()` loop. In theory, a simpler workaround would be to walk through the words in reverse order and to reverse the output as well at the end of the process. But this is a bit costly in JS and I didn't find a way to get a shorter version with this method. ``` a => // a[] = input array a.map((w, y) => // for each word w at position y in a[]: a[~y] = // save a pointer to the current entry in a[~y] w.map(m = // initialize m to a non-numeric value (c, x) => ( // for each character c at position x in w: p = a[y - 1] \|\| 0, // p = previous word or a dummy object m \|= c != p[x] // set m = 1 as soon as w differs from p at this position ) ? // if w is no longer equal to p: c // append c : // else: p[x + 1] == w[x + 1] ? // if the next characters are still matching: ' ' // append a space : ( // else: g = y => // g() = recursive function to insert pipes a[y][x] < 1 ? // if a[y][x] is a space: g( // do a recursive call to g() y + 1, // with y + 1 a[y][x] = '\|' // and overwrite a[y][x] with a pipe ) // end of recursive call : // else: '+' // make the whole recursion chain return a '+' // which will be appended in the current entry )(-y) // initial call to g() with -y (this is ~y + 1) ) // end of map() over the characters ) // end of map() over the words ``` [Answer] # [JavaScript (Node.js)](https://nodejs.org), 125 122 118 117 bytes ``` a=>a.map((w,i)=>a[i]=w.map((T,k)=>+i&&l[k]==T?l[-~k]<w[-~k]?(g=_=>a[--i][k]<"+"?g(a[i][k]="\|"):"+")():" ":(i=l=w,T))) ``` [Try it online!](https://tio.run/##jZDRboMgGIXvfQrCRYWoPEBT6kt4x8hCCzoqghU7s2TZqzt0u1CaJbs6nC@H8/9wE@/CXwfdj4V1Us01nQU9C9KJHqEp1zgYpjmdfkiVt4Fk@nAwrOWUVqVhxVfLT9MqJWro63KjKDQPgRPMYNmgpWGJw0@IjwFhFATAI9LU0CmvMMbz1VnvjCLGNahGLAGAEUKg6F2jFOT5BoTIx470e2dU5PX9EaN9wQh5wvH6RA/oGXhyc9qiNMX49/RiUwwysGqS/LHsRRipBin826Y9QKPGCDhna/0UC1T7p@gODM5JbZsIdRsvnQ1rRGBUxog9s5HfjpGP7vKvL8HzNw "JavaScript (Node.js) – Try It Online") * thanks to @Arnauld for tio testing :) [Answer] # Python, ~~263~~ 260 bytes -3 bytes thanks to Jonathan Frech Code: ``` p=lambda t,f,g:"\n".join([(f[:-1]+"+"if(a!=min(t))g else"")+a+p(t[a],(f+" "if len(t[a])>1or a==max(t)else f[:-1]+"\| "),1)for a in t])if t else"" def a(t,x): if x:c=x[0];t[c]=c in t and t[c]or{};a(t[c],x[1:]) def f(s):t={};[a(t,i)for i in s];return p(t,"",0) ``` [Try it Online!](https://tio.run/##pVDBbsMgDL3zFYwTNKxqtFsq9iNZDrRAykQgS1wp1bZvzwzNdtpl2gG/h@33bBhvcEnxaV1HFfRwMpqCdLJv2Etk@9fkI2@5a5vHuqtYxbzj@kENmAUhdj21YbaMiUpXI4dWd5K7ilFso8HGkhHPdZqoVmrQC4qygH77fVAmZC1cbqA@UugEKmFzJcY6qjnIRTSEYmFpzmppD90R2nOnzkVBdTQ039P0/nnEbqRyaeumE0Xv@G4WDSgsttnLl2k@a@fuOFm4TpHi7pIxeRDrOPkIlKOKMXbSwdjJ6PlCkAYLBVKKzm8p5H7e0ghTSsbHvpABDfbzGDzw/JVCCEI2d/ywH36fRPSYemszhNTfEMd8gi3Rv13vJBeA/Mn4f28gJkU0KAA2BJ1ZLBGIuQ6nX5ZZvwA) Explanation: This solution builds a trie out of the input words and recursively parses it into the required output. The a function takes a trie t and a string s and adds x to t. Tries are implemented as nested dictionaries. Each dictionary represents a node in the trie. For example, the dictionary representing the trie generated by the first test case looks like this: ``` {'b': {'a': {'l': {'d': {'e': {'r': {'d': {'a': {'s': {'h': {}}}}}}}, 'l': {'e': {'t': {}}, 'o': {'o': {'n': {'f': {'i': {'s': {'h': {}}}}, 'i': {'s': {'t': {}}}}}, 't': {}}}}}, 'r': {'o': {'o': {'d': {'i': {'n': {'g': {}}}}, 'm': {}}}}}} ``` The p function recurses through this structure and generates the string representation of the trie expected by the challenge. The f function takes a bunch of strings as arguments, adds them all to a trie with a, then returns the result of calling p on the trie. [Answer] # [C (gcc)](https://gcc.gnu.org/), 165 155 bytes Takes three arguments: * `char** a` : an array of null-terminated words * `char* m` : an array of the length of each word * `int n` : the number of words in the array ``` f(a,m,n,i,j)char*a,m;{for(i=n;--i;)for(j=0;j<m[i]&j<m[i-1]&a[i][j]==a[i-1][j];j++)a[i][j]=a[i][j+1]^a[i-1][j+1]?43:++i<n&j<m[i]&a[i--][j]%81==43?124:32;} ``` [Try it online!](https://tio.run/##fVFdi4MwEHz3VwShJdbI1dqHo6n0h3gepBrbiG5KtBxc8bd7Gz9q@3Ig7MzOZmYTs@CSZX1fUMFqBkyx0suuwmw2gm1q/ii0oSoGHgSKe5aU8ZaXxzpR6XooQZiuBbKkTONYDBwhL33fm9tj9cP0e9YRn/bRwffVEdaTm9UCO7/6DON4H53C3f4Q7XjXD/uQSjVtkpKYPBxC3LOocmly0VxdNvFKtgvWGgr1KmIDDV74jI3WuYLLwuoR5howY8GtrCrxpLDAySi/12fX6bjjKGhJLRRQb9jVUsC9G/UrdUHtPTzy8UqTbepxnBwv@qNN3iSQzh1SSZgofvgPCLWWCi23HMuRABZ87yGNTOeVfaqmNfn9NmaoMYMMdrOK@E3tphA6mDA7ywh4S/b/0TeDckHdVfMFLntuMgUXRkr61uucrv8D "C (gcc) – Try It Online") [Answer] # [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~149 144~~ 142 bytes ``` {1 while s/(\n.)\s(.)$0(\+\|\\|)/$0\|$1$0$2/;$_}o{$=({.[1].subst(/^(.+)<?{.[0].index($0)eq 0}>/,{' 'x$0.ords-1~'+'})}for '',\|$_ Z$_).join(" ")} ``` [Try it online!](https://tio.run/##LYzLbsMgFAX3/oqr6KpAnGLcRTd59D9ap5YtcEKEoQVHTWTTX3eplc2Z0SzOl/Lmde7v8NTBHuaxhJ@zNgpCQSvL16wKNC0KWuVTNbECxYQlCnwptlhHN@KejvyjPPJwbcNAi0/Kc7Z7S00cubZS3SgKpr5BxEOxGQmQGwruvAzP5S/JSWSxcx4I2UxYwzvWjF@ctnSVrVicQ3OHju7axkjlZRPOWVKjhgXO2U4/UnIdHjnBOye1PS3SZ9LZdLBgUMY0/2aXHTJ57dsD285/ "Perl 6 – Try It Online") I'm sure this can be golfed a more, especially as I'm not an expert on regexes. This uses much the same process as [Neil's Retina answer](https://codegolf.stackexchange.com/a/170584/76162). [Answer] # [Ruby](https://www.ruby-lang.org/), 118 bytes ``` ->a{i=1;a.map{s="";a[i+=j=-1].chars{\|c\|a[i][j+=1]=i<0&&a[i-1][/^#{s+=c}/]?a[i+1][j]=~/[\|+]/??\|:?\s:c}[/[\| ]\b/]&&=?+}} ``` [Try it online!](https://tio.run/##Rc7BcoMgEAbgu0@RsTNeaEK9xm54EEJmFkWDg2JFDxk1r26h0ebE9@8PO/SjfKwlrMcLThrSDE8NdpODOM6QawI1HFNxyu/Yu2nOZz8TvCaQCtDfX0nis@85vX1MjkC@UMHCMz@qBTwpn4mgjM1ndnXnfOF@cBBXSUWSACPLsiLwGDtbKRV/RkHGVo8Xu@0waof@Gf@9XRpiEUXSL5FoCtUX6O6h8MmoYZe1banfhY/avcuXemsL3Va7m4DCtn7rrkEZg1tod/w9LsZGhn@UHEXWjYM7oLfcLNdf "Ruby – Try It Online") Accepts an array of strings, outputs by modifying the original input array in-place. ## Explanation The basic string transformation is not too complex, but in order to insert vertical pipes properly, we need to iterate in reverse order, and since `reverse` method is quite verbose, we'll do it in a trickier way. Here, we use `map` just to run the loop, leave the first word alone, and then iterate from the end using negative indices: ``` ->a{ i=1; #Initialize word indexer a.map{ #Loop s=""; #Initialize lookup string a[i+=j=-1] #Initialize char indexer and decrement i .chars{\|c\| #Loop through each char c of current word a[i][j+=1]= #Mofify current word at position j i<0&& #If it's not the first word and a[i-1][/^#{s+=c}/]? #Word above matches current one from start to j a[i+1][j]=~/[\|+]/? #Then if char below is \| or + ?\|:?\s:c #Then set current char to \| Else to Space Else leave as is }[/[\| ]\b/]&&=?+ #Finally, replace Space or \| at word boundary with + } } ``` [Answer] # [Python 2](https://docs.python.org/2/), 191 bytes ``` def f(w,r=['']): for b,c in zip(w[1:],w)[::-1]: s='';d=0 for x,y,z in zip(r[0]+b,b,c+b):t=s[-1:];s=s[:-1]+[['+'*(s>'')+y,t+' \|'[x in'+\|']][y==z],t+y][d];d=d\|(y!=z) r=[s]+r return[w[0]]+r ``` [Try it online!](https://tio.run/##RZHBcoMgEIbP8SnoabWQTtIjGfoilIMWNHQIWMAxOL67xUab037/7v/vMkOf4tXZ92WRqkVtORLPOICoaIFa51FDvpC2aNJ9OfIzFWSsOKXHs6DFITCAi2Sn4rA67ySRafd6fhK4ITmNm4pGFvgxhy8hwxrGnAOG1zJ8AFQ4kYgBzcDvOQ54BiF4YmwSuZ8ElyIfkXOZXthUFYf8viCwL5BXcfCWj/lU1kvvtY0IPi28fTtty7bkUPeuUwoIWsm4Lj2w34pRO@if4Z83U1xLUxupvKzDdVNG7X3jnG31c5ClDs/hg7xzUttu59sK0tm8daeojKk3YXf4C8vh1uSPqIrlFw "Python 2 – Try It Online") ]
[Question] [ [BS](http://en.wikipedia.org/wiki/Cheat_%28game%29) is a card game where the object of the game is to lose all of your cards. A game consists of four players and a 52-card deck. Each player is randomly dealt 13 cards. Normally, cards are labeled 2 - 10, Ace, Jack, Queen, King, but for simplicity, the cards will be labeled with a number from 0 - 12 inclusive. Although the number of cards in a player's hand is public information, only the player knows what specific cards are in his hand. The game goes as follows: the first player places as many cards labeled 0 as he wants to in the discard pile (note that he is not required to play all of his cards labeled 0, though usually it is in his best interest to do so). He must play at least one card. The second player plays as many cards as he wants to labeled 1, the third player plays 2, and so on. After 12, it resets to 0. What happens if you don't have any of the cards that you are supposed to play? Remember, you must play at least one card -- in fact, you can play any cards you want! (Actually, even if you have the right card, you can lie and play a different card). However, someone can call you out and say, "BS!" If that someone is correct and you had lied, then you must take all the cards in the discard pile; as a reward, the player who called you out randomly places one of their cards in the discard pile. If the accuser is wrong, however, he must take all the cards in the discard pile. Note that you can't lie about the number of cards that you play. More detailed info: * At the beginning of the game, four random players are chosen to play. Since there will be at least 1000 games, each player will get a chance to play. The turn order is randomly decided at the beginning of the game * If you return one correct card and one incorrect card, then it is considered lying (i.e. if you were supposed to give 2s, and you gave one 2 and one 1, then that's lying) * If two or more players both say BS at the same time, then one is randomly chosen. * Your score is the percent of games that you win. * There is a maximum 1000 rounds, where one round is every player going once. Usually, someone wins before this. If no one wins, then it is counted towards the total number of games played, but no one wins. Spec: You should write a class which extends `Player`. It will look like: ``` package players; import java.util.ArrayList; import java.util.List; import controller.; public class Player1 extends Player { @Override protected List<Card> requestCards(int card, Controller controller) { Card[] hand = getHand(); List<Card> ret = new ArrayList<Card>(); for (Card c : hand) { if (c.getNumber() == card) { ret.add(c); } } if (ret.size() == 0) ret.add(hand[0]); return ret; } @Override protected boolean bs(Player player, int card, int numberOfCards, Controller controller) { return numberOfCards >= 3; } protected void update(Controller controller) { // This method gets called once at the end of every round } protected void initialize(Controller controller) { // This method gets called once at the beginning once all the cards are dealt } public String toString() { return "Player 1"; } } ``` The method `requestCards` is called when it is your turn. The argument `card` is the card number that you are supposed to provide. You return a list of cards that you want to put in the discard pile. The player above checks to see if he has any cards of the requested card type; if not, he simply plays his first card and hopes no one checks. The method `bs` is called whenever someone else plays a card. The first argument is the player, the second - the card he was supposed* to play, and the third - the number of that type of card that he claims that he has played. Return `true` if you want to call "BS." In the code above, the player only calls "BS" when the other player claims to have 3 or more cards of the requested type. The last argument for both methods is `controller`, which is just the controller that controls the game. From the controller, you can get more public information, such as the number of cards in the discard pile or the list and turn order of the players. The `toString` method is optional. Conroller on GitHub: <https://github.com/prakol16/bs> If you want to post a non-java solution, you can use the interface provided in <https://github.com/LegionMammal978/bs> (credits to LegionMammal978) and I'll try to integrate it. Scoreboard so far: ``` class players.PlayerConMan: 2660/4446 = 59.82905982905983% class players.CalculatingLiar: 2525/4426 = 57.049254405784005% class players.PlayerTruthy: 1653/4497 = 36.75783855903936% class players.Player4: 1446/4425 = 32.67796610169491% class players.Player1: 536/4382 = 12.23185759926974% class players.Player3: 493/4425 = 11.141242937853107% class players.Player2: 370/4451 = 8.312738710402156% class players.LiePlayer: 317/4432 = 7.152527075812275% class players.Hoarder: 0/4516 = 0.0% ``` PlayerConMan is winning, but CalculatingLiar is in a close second. These scores seem consistent -- they are fairly the same every time. [Answer] # ConMan ConMan watches every card that goes through his hand, calling BS when a play isn't possible due to where the cards are. Plays truth when able, but lies intelligently using the last card if a victory were to happen. I spent a long time tuning a technique to call BS when the probability was high that the opponent was lying, or when calling BS was beneficial (such as getting useful cards from the discard pile), but in practice, not calling BS at all netted me the most points. ``` package players; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import controller.; import java.text.DecimalFormat; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.Iterator; public class PlayerConMan extends Player { private enum Location { PLAYER_0, PLAYER_1, PLAYER_2, PLAYER_3, DISCARD, UNKNOWN }; private class MyCard { private final int number; private Location location; private double confidence; protected Card card; public MyCard(int x) { this.number = x; location = Location.UNKNOWN; confidence = 1.0; } @Override public String toString() { if (confidence > 0.75) { return ""+number; } else if (confidence > 0.25) { return number+""; } else { return number+"_"; } } } private final ArrayList<ArrayList<MyCard>> theDeck = new ArrayList(); private Location myLocation; private ArrayList<Player> players; private final ArrayList<MyCard> myHand = new ArrayList(); private final HashMap<Location, Integer> sizes = new HashMap(); private ArrayList<Integer> lies = new ArrayList(); private ArrayList<Integer> truths = new ArrayList(); // Constructor public PlayerConMan() { for (int i = 0; i < 13; ++i) { ArrayList<MyCard> set = new ArrayList(); for (int j = 0; j < 4; ++j) { set.add(new MyCard(i)); } theDeck.add(set); } sizes.put(Location.PLAYER_0, 13); sizes.put(Location.PLAYER_1, 13); sizes.put(Location.PLAYER_2, 13); sizes.put(Location.PLAYER_3, 13); sizes.put(Location.DISCARD, 13); sizes.put(Location.UNKNOWN, 39); } //Gets the MyCard for this card, updating a MyCard with the lowest confidence if not already created private MyCard getCard(Card c) { ArrayList<MyCard> set = theDeck.get(c.getNumber()); MyCard unknown = null; double confidence = 1.0; for (MyCard m : set) { if (m.card == c) { return m; } if (m.card == null) { if (m.location == Location.UNKNOWN) { unknown = m; confidence = 0.0; } else if (m.confidence < confidence \|\| unknown == null) { unknown = m; confidence = m.confidence; } } } unknown.card = c; return unknown; } //Returns the Location of a player private Location getLocation(Player p) { return Location.values()[players.indexOf(p)]; } @Override protected void initialize(Controller controller) { super.initialize(controller); players = new ArrayList(controller.getPlayers()); for (Player p : players) { if (p == this) { myLocation = getLocation(p); } } for (Location loc : Location.values()) { sizes.put(loc, 0); } } private ArrayList<Integer>[] getTruthesAndLies(Player player, int card, ArrayList<MyCard> myHand) { //Determine our next plays int offset = players.indexOf(player); int myOffset = players.indexOf(this); int nextCard = (card + (myOffset - offset + 4) % 4)%13; ArrayList<Integer> truths = new ArrayList(); ArrayList<Integer> lies = new ArrayList(); ArrayList<MyCard> cardsLeft = new ArrayList(myHand); while (!cardsLeft.isEmpty()) { boolean isLie = true; Iterator<MyCard> it = cardsLeft.iterator(); while (it.hasNext()) { MyCard m = it.next(); if (m.number == nextCard) { it.remove(); isLie = false; } } if (isLie) { lies.add(nextCard); } else { truths.add(nextCard); } nextCard = (nextCard + 4)%13; } return new ArrayList[]{truths, lies}; } private void updateDeck(Player player, int card, int numberOfCards, Controller controller) { Location loc = getLocation(player); //Update from BS if (sizes.get(Location.DISCARD) + numberOfCards != controller.getDiscardPileSize()) { //Move all cards from DISCARD to the losing player // Losing player defaults to player playing, in the rare case of a tie Location losingPlayer = loc; Location winningPlayer = null; for (Player p : players) { Location pLoc = getLocation(p); int size = p.handSize(); if (pLoc == loc) size += numberOfCards; if (p.handSize() > sizes.get(pLoc)) { losingPlayer = pLoc; } else if (size < sizes.get(pLoc)) { winningPlayer = pLoc; } } if (winningPlayer == null) { debug(losingPlayer+" lost a BS"); } else { debug(losingPlayer+" lied and "+winningPlayer+" lost a card"); } //Move the cards from the discard to the player ArrayList<MyCard> winnersHand = new ArrayList(); for (ArrayList<MyCard> set : theDeck) { for (MyCard m : set) { if (m.location == Location.DISCARD) { if (losingPlayer == myLocation) { //If we lost, update the discard cards to unknown; // They'll be updated when we look at our hand m.location = Location.UNKNOWN; m.confidence = 1.0; } else { //Move to the losing player m.location = losingPlayer; } } else if (m.location == myLocation && winningPlayer == myLocation) { //Update our old cards to the discard pile, in case we won m.location = Location.DISCARD; m.confidence = 1.0; } else if (m.location == winningPlayer) { //Add the card to the winner's hand for later processing winnersHand.add(m); } } } //If someone else won, adjust the probabilities on their cards if (winningPlayer != myLocation && winningPlayer != null) { int winningSize = players.get(winningPlayer.ordinal()).handSize(); if (winningPlayer == loc) winningSize += numberOfCards; for (MyCard m : winnersHand) { m.confidence = 1-(1/winningSize); } } } sizes.put(Location.DISCARD, controller.getDiscardPileSize()); //Update player handSize for (Player p : players) { sizes.put(getLocation(p), p.handSize()); } //Detect if my hand size has changed to speed processing if (myHand.size() != handSize()) { //Update values from my hand myHand.clear(); for (Card c : getHand()) { MyCard m = getCard(c); m.location = myLocation; m.confidence = 1.0; myHand.add(m); } //Determine our next plays ArrayList<Integer> tl[] = getTruthesAndLies(player, card, myHand); truths = tl[0]; lies = tl[1]; debug("Truthes: "+truths); debug("Lies: "+lies); } } @Override protected List<Card> requestCards(int card, Controller controller) { updateDeck(this, card, 0, controller); ArrayList<Card> ret = new ArrayList(); int pick = card; boolean all = true; if (truths.get(0) != card) { pick = truths.get(truths.size()-1); all = false; } for (MyCard m : myHand) { if (m.number == pick) { m.location = Location.DISCARD; ret.add(m.card); if (!all) break; } } sizes.put(Location.DISCARD, controller.getDiscardPileSize() + ret.size()); sizes.put(myLocation, myHand.size() - ret.size()); printTheDeck(); return ret; } @Override protected boolean bs(Player player, int card, int numberOfCards, Controller controller) { updateDeck(player, card, numberOfCards, controller); Location loc = getLocation(player); //Get total number of unknown cards and total number of cards the player must have int handSize = player.handSize() + numberOfCards; ArrayList<MyCard> playerHand = new ArrayList(); ArrayList<MyCard> discardPile = new ArrayList(); double totalUnknown = 0; double playerUnknown = handSize; double cardsHeld = 0; double cardsNotHeld = 0; for (ArrayList<MyCard> set : theDeck) { for (MyCard m : set) { if (m.location == Location.UNKNOWN) { totalUnknown++; } else if (m.location == loc) { playerHand.add(m); playerUnknown -= m.confidence; totalUnknown += 1.0 - m.confidence; if (m.number == card) { cardsHeld += m.confidence; } } else { if (m.location == Location.DISCARD) { discardPile.add(m); } totalUnknown += 1.0 - m.confidence; if (m.number == card) { cardsNotHeld += m.confidence; } } } } boolean callBS = false; double prob; int possible = (int)Math.round(4-cardsNotHeld); int needed = (int)Math.round(numberOfCards - cardsHeld); if (needed > possible) { //Player can't possibly have the cards prob = 0.0; debug("impossible"); callBS = true; } else if (needed <= 0) { //Player guaranteed to have the cards prob = 1.0; debug("guaranteed"); } else { //The probability that player has needed or more of the possible cards double successes = 0; for (int i = (int)needed; i <= (int)possible; i++) { successes += choose(possible, i) choose(totalUnknown-possible, playerUnknown-i); } double outcomes = choose(totalUnknown, playerUnknown); prob = successes / outcomes; if (Double.isNaN(prob)) { prob = 0; callBS = true; } debug("prob = "+new DecimalFormat("0.000").format(prob)); } //Update which cards they may have put down // Assume they put down as many as they could truthfully int cardsMoved = 0; Iterator<MyCard> it = playerHand.iterator(); while (it.hasNext()) { MyCard m = it.next(); if (m.number == card) { it.remove(); m.location = Location.DISCARD; discardPile.add(m); cardsMoved++; if (cardsMoved >= numberOfCards) { break; } } } //We can't account for all the cards they put down // Adjust existing probabilities and move our lowest confidence cards to the discard if (cardsMoved < numberOfCards) { // Reduce the confidence of all remaining cards, in case they lied // Assumes they lie at random double cardsLeft = handSize-cardsMoved; double cardsNeeded = numberOfCards-cardsMoved; double probChosen = 1 * choose(cardsLeft-1, cardsNeeded-1) / choose(cardsLeft, cardsNeeded); if (Double.compare(cardsLeft, cardsNeeded) == 0) { //They're gonna win, call their bluff callBS = true; for (MyCard m : playerHand) { m.location = Location.DISCARD; } } else { for (MyCard m : playerHand) { m.confidence = (1-probChosen) (1-prob) + prob; } } // Move any UNKNOWN cards they could have played, assuming they told the truth Collections.sort(theDeck.get(card), new Comparator<MyCard>() { @Override public int compare(MyCard o1, MyCard o2) { double p1 = o1.confidence - (o1.location == Location.UNKNOWN ? 10 : 0); double p2 = o2.confidence - (o2.location == Location.UNKNOWN ? 10 : 0); return (int)Math.signum(p1-p2); } }); for (MyCard m : theDeck.get(card)) { if (m.location == Location.UNKNOWN \|\| m.confidence < prob) { m.location = Location.DISCARD; m.confidence = prob; cardsMoved++; discardPile.add(m); if (cardsMoved >= numberOfCards) break; } } } //Get the confidence of the discardPile double discardPileConfidence = 1.0; for (MyCard m : discardPile) { discardPileConfidence = m.confidence; } discardPileConfidence = Math.pow(0.5, controller.getDiscardPileSize() - discardPile.size()); //Call BS if the cards in the discard pile consists only of cards we need / will play if (discardPileConfidence > 0.5 && discardPile.size() == controller.getDiscardPileSize()) { double truthCount = 0; double lieCount = 0; double unknownCount = 0; for (MyCard m : discardPile) { if (truths.contains(m.number)) { truthCount += m.confidence; unknownCount += 1-m.confidence; } else if (lies.contains(m.number)) { lieCount += m.confidence; unknownCount += 1-m.confidence; } else { unknownCount += 1; break; } } if (lieCount > 0 && unknownCount < 1) { debug("Strategic BS"); //callBS = true; } } //What's the worst that could happen? //Test the decks' ArrayList<MyCard> worstHand = new ArrayList<MyCard>(myHand); worstHand.addAll(discardPile); ArrayList<Integer> loseCase[] = getTruthesAndLies(player, card, worstHand); int winPlaysLeft = truths.size() + lies.size(); int losePlaysLeft = loseCase[0].size() + loseCase[1].size(); double randomPlaysLeft = Math.max(losePlaysLeft,7); double expectedPlaysLeft = losePlaysLeft * discardPileConfidence + randomPlaysLeft * (1-discardPileConfidence); double threshold = 0.0 - (expectedPlaysLeft - winPlaysLeft)/13.0; debug("winPlaysLeft = "+winPlaysLeft); debug("expectedPlaysLeft = "+expectedPlaysLeft); debug("Threshold = "+threshold); if(lies.isEmpty()) { threshold /= 2; } //callBS = callBS \|\| prob < threshold; printTheDeck(); return callBS; } static double logGamma(double x) { double tmp = (x - 0.5) * Math.log(x + 4.5) - (x + 4.5); double ser = 1.0 + 76.18009173 / (x + 0) - 86.50532033 / (x + 1) + 24.01409822 / (x + 2) - 1.231739516 / (x + 3) + 0.00120858003 / (x + 4) - 0.00000536382 / (x + 5); return tmp + Math.log(ser * Math.sqrt(2 * Math.PI)); } static double gamma(double x) { return Math.exp(logGamma(x)); } static double factorial(double x) { return x * gamma(x); } static double choose(double n, double k) { if (Double.compare(n, k) == 0 \|\| Double.compare(k, 0) == 0) return 1.0; if (k < 0 \|\| k > n) { return 0.0; } return factorial(n) / (factorial(n-k) * factorial(k)); } public String toString() { return "ConMan"; } public void printTheDeck() { HashMap<Location, ArrayList<MyCard>> map = new HashMap(); for (Location loc : Location.values()) { map.put(loc, new ArrayList()); } for (ArrayList<MyCard> set : theDeck) { for (MyCard m : set) { map.get(m.location).add(m); } } String ret = ""; for (Player p : players) { ret += p.toString()+": "+map.get(getLocation(p))+"\n"; } ret += "Discard pile: "+map.get(Location.DISCARD)+"\n"; ret += "Unknown: ("+map.get(Location.UNKNOWN).size()+" cards)\n"; debug(ret); } public void debug(Object s) { } } ``` [Answer] # Player 3131961357\_10 Picks a random player each game, and always calls BS on that player. ``` package players; import java.util.ArrayList; import java.util.List; import controller.; public class Player3131961357_10 extends Player{ private int[] ducks = new int[13]; private Player target = null; private int cake = 0; @Override protected List<Card> requestCards(int bacon, Controller controller){ Card[] hand = getHand(); List<Card> ret = new ArrayList<Card>(); List<Card> others = new ArrayList<Card>(); for(Card c:hand){ if(c.getNumber() == bacon){ ret.add(c); }else{ others.add(c); } } if(ret.size() == 0){ ImperfectPlayer.moveRandom(others, ret); } if(others.size() > 0 && ret.size() < 3 && handSize() > ret.size() + 1){ ImperfectPlayer.moveRandom(others, ret); } return ret; } private final int someoneLied = 0; @Override protected boolean bs(Player player, int bacon, int howMuchBacon, Controller controller){ if(target == null){ // Could not find my cake. // Someone must have taken it. // They are my target. List<Player> players = controller.getPlayers(); do target = players.get((int)Math.floor(Math.random() players.size())); while(target != this); } int count = 0; Card[] hand = getHand(); for(Card c:hand){ if(c.getNumber() == bacon) ++count; } if(cake >= controller.getDiscardPileSize()){ ducks = new int[13]; cake = someoneLied; } ducks[bacon] += howMuchBacon; cake += howMuchBacon; if(player.handSize() == 0) return true; return player.handSize() == 0 \|\| howMuchBacon + count > 4 \|\| ducks[bacon] > 5 \|\| player == target \|\| Math.random() < 0.025; // why not? } public String toString(){ return "Player 3131961357_10"; } public static <T> void moveRandom(List<T> from, List<T> to){ T a = from.remove((int)Math.floor(Math.random() * from.size())); to.add(a); } } ``` [Answer] # Truthy Not quite finished, since I don't know how to tell the result of calling BS (if they took the pile, or someone else in case of tie, or I did). At the moment, only call BS if I can prove it. Don't lie unless I have to. I need to improve the lying algorithm. I'm trying to make it as close as possible to how I play BS against other players (minus randomly putting extra cards underneath to play 5 or 6 without them knowing.) ``` package players; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import controller.; public class PlayerTruthy extends Player { private List<Card> played; private int discardPileSize; private HashMap<String,Integer> handSizes; private boolean initialized; //controller.getDiscardPileSize() // Constructor public PlayerTruthy() { played = new ArrayList<Card>(); handSizes = new HashMap<String,Integer>(); discardPileSize = 0; initialized = false; } // Initialize (do once) private void init(Controller controller) { for (Player p : controller.getPlayers()) { handSizes.put(p, 0); } initialized = true; } @Override protected List<Card> requestCards(int card, Controller controller) { if (!initialized) { init(controller); } List<Card> cards = getCards(card); if (cards.size() == 0) { cards = lieCards(card); } played.addAll(cards); return cards; } @Override protected boolean bs(Player player, int card, int numberOfCards, Controller controller) { if (!initialized) { init(controller); } List<Card> hand = Arrays.asList(getHand()); int count = countCards(hand, card); return numberOfCards > 4-count; } public String toString() { return "Truthy"; } private int countCards(List<Card> list, int card) { int count = 0; for (Card c : list) { if (c.getNumber() == card) { count++; } } return count; } private List<Card> getCards(int card) { List<Card> cards = new ArrayList<Card>(); Card[] hand = getHand(); for (Card c : hand) { if (c.getNumber() == card) { cards.add(c); } } return cards; } private List<Card> lieCards(int card) { List<Card> hand = Arrays.asList(getHand()); List<Card> cards = new ArrayList<Card>(); int limit = 1; int count = 0; int index = (card+9) % 13; while (cards.size() == 0) { count = countCards(hand, index); if (count <= limit) { cards = getCards(index); } if (limit >= 3) { cards.removeRange(1, cards.size()); } if (index == card) { limit++; } index = (index+9) % 13; } return cards; } } ``` [Answer] # CalculatingLiar This one tries to play truth. If he lies, he uses a card that he won't use in the near future. It also tries to win trough calling BS on other players, since the last card almost never fits. ``` package players; import java.util.ArrayList; import java.util.Collections; import java.util.List; import controller.Card; import controller.Controller; import controller.Player; public class CalculatingLiar extends Player { private final List<Integer> knownCardsOnDeck = new ArrayList<>(); private int lastDeckSize = 0; @Override protected List<Card> requestCards(int card, Controller controller) { Card[] hand = getHand(); List<Card> ret = new ArrayList<Card>(); for (Card c : hand) { if (c.getNumber() == card) { ret.add(c); } } if (ret.size() == 0) { ret.add(calculateWorstCard(card)); } update(controller); for (Card c : ret) { knownCardsOnDeck.add(c.getNumber()); } lastDeckSize = controller.getDiscardPileSize() + ret.size(); return ret; } @Override protected boolean bs(Player player, int card, int numberOfCards, Controller controller) { Card[] hand = getHand(); int myCards = 0; for (Card c : hand) { if (c.getNumber() == card) myCards++; } update(controller); for (Integer number : knownCardsOnDeck) { if (number == card) { myCards++; } } return player.handSize() == 0 \|\| numberOfCards > 4 \|\| myCards + numberOfCards > 4 \|\| (player.handSize() < 5 && handSize() == 1); } @Override protected void initialize(Controller controller) { knownCardsOnDeck.clear(); lastDeckSize = 0; } @Override protected void update(Controller controller) { if (lastDeckSize > controller.getDiscardPileSize()) { knownCardsOnDeck.clear(); lastDeckSize = controller.getDiscardPileSize(); } else { lastDeckSize = controller.getDiscardPileSize(); } } private Card calculateWorstCard(int currentCard) { List<Integer> cardOrder = new ArrayList<>(); int nextCard = currentCard; do { cardOrder.add(nextCard); nextCard = (nextCard + 4) % 13; } while (nextCard != currentCard); Collections.reverse(cardOrder); Card[] hand = getHand(); for (Integer number : cardOrder) { for (Card card : hand) { if (card.getNumber() == number) { return card; } } } //never happens return null; } @Override public String toString() { return "(-"; } } ``` [Answer] # Hoarder ``` package players; import java.util.ArrayList; import java.util.List; import controller.; public class Hoarder extends Player{ @Override protected List<Card> requestCards(int card, Controller controller) { Card[] hand = getHand(); List<Card> ret = new ArrayList<Card>(); if( canWinHonestly(card) ) { //Hoarded enough cards that I won't have to bs ever again, time to win. for (Card c : hand) { if (c.getNumber() == card) { ret.add(c); } } } else { // Don't have the cards I'll need in the future. Play my entire hand. Either get more cards or instantly win. for (Card c : hand) { ret.add(c); } } return ret; } @Override protected boolean bs(Player player, int card, int numberOfCards, Controller controller) { //Don't call unless I have to, don't want to lose a random card return (player.handSize() <= numberOfCards); } @Override public String toString() { return "Hoarder"; } private boolean canWinHonestly(int card) { Card[] hand = getHand(); List<Integer> remainingCards = new ArrayList<Integer>(); for (Card c : hand) { remainingCards.add(c.getNumber()); } while( remainingCards.size() > 0 ) { if(remainingCards.contains(card)) { remainingCards.remove((Integer) card); card = (card + 4) % 13; } else { return false; } } return true; } } ``` Very simple strategy, collects cards until it can go on an honesty streak and win. Wasn't able to test it, hopefully my Java isn't too rusty. [Answer] # LiePlayer Lays down at least 2 cards, even if that means stretching the truth. ``` package players; import java.util.ArrayList; import java.util.List; import controller.*; public class LiePlayer extends Player { @Override protected List<Card> requestCards(int card, Controller controller) { Card[] hand = getHand(); List<Card> ret = new ArrayList<Card>(); for (Card c : hand) { if (c.getNumber() == card) { ret.add(c); } } int i=0; while(ret.size()<2 && i<cards.length){ if(c.getNumber() != card){ ret.add(hand[i]) } i++; } return ret; } @Override protected boolean bs(Player player, int card, int numberOfCards, Controller controller) { Card[] hand = getHand(); int myCards = 0;//How meny of that card do I have. for (Card c : hand) { if (c.getNumber() == card) { myCards += 1; } } return numberOfCards+myCards >= 4; //for that to work, he would have to have all the other cards of that number. } public String toString() { //Why would we admit to lying? return "Truthful Player"; } } ``` ]
[Question] [ ## Introduction Santa has too many names to process, and needs your help! He needs you to write a program or a function, which outputs `nice`, `naughty`, `very naughty` or `very very naughty`. To determine how nice or naughty someone is, Santa had developed an algorithm: Nice ([division](/questions/tagged/division "show questions tagged 'division'"), [math](/questions/tagged/math "show questions tagged 'math'")): First of all, we obtain a number from the name by adding all the letters up (spaces ignored). For example: ``` Doorknob = D = 4 o = 15 o = 15 r = 18 k = 11 n = 14 o = 15 b = 2 4 + 15 + 15 + 18 + 11 + 14 + 15 + 2 = 94 ``` If the number of divisors is equal to the length of the name, the person is considered `nice`. This means that your program should output `[name] has been nice`. Here, the divisors of `94` are: ``` Divisors of 94: 1, 2, 47, 94 ``` There are `4` divisors, but the name has length `8` (spaces included). Conclusion, `Doorknob` has not been nice. So we continue our journey: --- Naughty ([sequence](/questions/tagged/sequence "show questions tagged 'sequence'"), [math](/questions/tagged/math "show questions tagged 'math'")): Santa has developed a new sequence, the christmas number. First, we will look at the following christmas trees: ``` n = 1 n = 2 n = 3 n = 4 * * * *** ******* _ * * \| * *** \| * ***** * \| ***** ******* * * \| * * * ***** nn \| ** *** * * \| *** *** * \| * ********* * \| *** * \|_***** *** * ***** \|_____\| ******* 2n+1 * 5 18 47 98 ``` The amount of asterisks determines the christmas number. The sequence goes as following: `5, 18, 47, 98, 177, ...`. From here, we can conclude that `94` is not a christmas number. That means that `Doorknob` has not just been naughty. --- Very naughty ([string](/questions/tagged/string "show questions tagged 'string'")): For this, we need to find out if `Doorknob` is a raising ladder string. This is determined by the letters in the name with `A = 1`, `B = 2`, `C = 3`, etc.: First we will look at the first letter, the `D`. This has value `4`. This is our starting point. The next letter is `o`. This has the value `15`, which is higher than our previous value, so we're going a step higher on the ladder. The next value is also an `o`. This is the same, so we're doing nothing. If the next value is higher than the current value, we will go a step higher. If the next value is lower than the current value, we will go a ster lower. If it's the same, we'll stay on the same step. This visualised for `Doorknob`, `Martin Buttner` and `Alex A`: ``` O / \ R N B / \ / O-O K T N U L X / / \ / \ / \ / \ / \ D M R I B T-T A E A \ / \ A N R \ / E ``` You can see that `Doorknob` ended higher than the starting position. So `Doorknob has been very naughty`. `Martin Buttner` and `Alex A` didn't get higher than the starting point. So they are both `very very naughty`. ## Test cases ``` Input: Doorknob Output: Doorknob has been very naughty Input: Martin Buttner Output: Martin Buttner has been very very naughty Input: Jakube Output: Jakube has been nice Input: B Output: B has been very very naughty ``` ## Rules * You need to provide a program or a function which takes input (which consists of at least one letter). * The input will consist of uppercase letters, lowercase letters and spaces. Spaces are ignored during the process, except for the length of the input. * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the submission with the least amount of bytes wins! [Answer] ## CJam, ~~109~~ ~~108~~ 107 bytes ``` l" has been "1$[_,\S-:eu'@f-:A:+__,:)f%0e=@=\_{)__2+*))}%&A2ew::-:g1b0<]{}#4,="very "_5>\"naughty""nice"? ``` [Try it online.](http://cjam.tryitonline.net/#code=bCIgaGFzIGJlZW4gIjEkW18sXFMtOmV1J0BmLTpBOitfXyw6KWYlMGU9QD1cX3spX18yKyoqKSl9JSZBMmV3OjotOmcxYjA8XXt9IzQsPSJ2ZXJ5ICIqXzU-XCJuYXVnaHR5IiJuaWNlIj8&input=U2FudGE) ### Explanation A full explanation will have to wait until later, but here is the code broken down into the different sections: ``` l" has been "1$[ e# Some preparation... _,\S-:eu'@f-:A:+ e# Determine letter sum. __,:)f%0e=@= e# Check divisor count. \_{)__2+*))}%& e# Check for Christmas number. A2ew::-:g1b0< e# Check ladder. ]{}#4,="very "_5>\"naughty""nice"? e# Determine nice/naughtiness. ``` [Answer] # Pyth 86 bytes Apparently I've been nice this year... ``` jd[z"has been"?qlzl{yPJsKxL+NG@Grz0"nice"+"very "&!}Jm++2ddd2SJhgs._M-VKtK0"naughty ``` Try it online: [Demonstration](https://pyth.herokuapp.com/?code=jd%5Bz%22has+been%22%3Fqlzl%7ByPJsKxL%2BNG%40Grz0%22nice%22%2B%2a%22very+%22%26%21%7DJm%2B%2a%2B2d%2add2SJhgs._M-VKtK0%22naughty&input=Jakube&test_suite=0&test_suite_input=Doorknob%0AMartin+Buttner%0AJakube%0AB&debug=0) or [Test Suite](https://pyth.herokuapp.com/?code=jd%5Bz%22has+been%22%3Fqlzl%7ByPJsKxL%2BNG%40Grz0%22nice%22%2B%2a%22very+%22%26%21%7DJm%2B%2a%2B2d%2add2SJhgs._M-VKtK0%22naughty&input=Jakube&test_suite=1&test_suite_input=Doorknob%0AMartin+Buttner%0AJakube%0AB&debug=0) ### Explanation: ``` jd[z"has been"... list with input string, "has been" and ...; join with spaces qlzl{yPJsKxL+NG@Grz0 compares the length of input with the number of divisors (computes all prime factors and counts the elements in the powerset) ?..."nice" if True, use "nice" as last list element else: }Jm++2ddd2SJ check for christmas number (checks, if its of the form n^3+2n^2+2) gs._M-VKtK0 check if raising ladder string ends lower or equal (assigns each neighbor pair a number -1,0,1 and computes the sum) &!...h... returns 0, 1 or 2 "very " repeat "very " this times +..."naughty add "naughty" and use this as the third list element ``` [Answer] # [MATL](https://esolangs.org/wiki/MATL), 117 bytes My longest MATL program so far :-) :-( Uses [current release](https://github.com/lmendo/MATL/releases/tag/3.1.0) of the language, which is earlier than this challenge. ``` jttk96-t0>)tstt:\~s4$bn=?xx'nice'}[1,2,0,2]99:ZQ=a?'naughty'}dt0>sw0<s-O>~'very naughty'w?'very 'wh]]]' has been 'whh ``` ### Examples ``` >> matl > jttk96-t0>)tstt:\~s4$bn=?xx'nice'}[1,2,0,2]99:ZQ=a?'naughty'}dt0>sw0<s-O>~'very naughty'w?'very 'wh]]]' has been 'whh > > Doorknob Doorknob has been very naughty >> matl > jttk96-t0>)tstt:\~s4$bn=?xx'nice'}[1,2,0,2]99:ZQ=a?'naughty'}dt0>sw0<s-O>~'very naughty'w?'very 'wh]]]' has been 'whh > > Jakube Jakube has been nice ``` ### Explanation ``` jt % input string. Duplicate tk96-t0>) % duplicate. Convert to lower, then to numbers, remove spaces ts % duplicate. Sum tt: % duplicate. Vector from 1 to obtained sum \~s % modulus operation. Count zeros to determine number of divisors 4$bn= % does it equal original name length? ? % if so xx'nice' % remove values not needed, and push string } % else [1,2,0,2]99:ZQ % all Christmas numbers =a % does sum equal any Christmas number? ? % if so 'naughty' % push string } % else dt0>s % total number of increases w0<s % total number of decreases -O>~ % subtract both. Is total <=0? 'very naughty'w % push string, which will be needed in either case. Swap ? % if total was <=0 'very 'wh % prepend string ] % end if ] % end if ] % end if ' has been 'whh % build complete string from pushed parts ``` [Answer] # Lua, ~~371~~ 284 bytes I'm sure there's room for improvement, I'd like to cut out some if's. Edit: 4 months later, I learned a lot about lua and wanted to get back to this submission, I did well: cutted out 87 bytes!* ``` a=... .." has been "s=(...):lower()b="very "x=0y=s:byte(1)-96z=0r="naughty"for i=2,#s do c=s:byte(i)y=c+y-96z=z+c<s:byte(i-1)and-1or 1 end for i=1,y do x=y%i<1 and x+1or x end for i=1,13 do d=y==i^3+2i^2+2 and 0or d end print(a..(x==#s and"nice"or(d and""or b..(z>0 and""or b))..r)) ``` ### Ungolfed ``` a=... .." has been " -- Start of the sentence s=(...):lower() -- convert the input to lower case b="very " x=0 -- y's divisor count y=s:byte(1)-96 -- will contain the sum of the char's position in the alphabet z=0 -- will contain the raising ladder state r="naughty" for i=2,#s -- iterate over each character in s do c=s:byte(i) -- shorthand for the byte value of the current char y=c+y-96 -- increment the sum of letter's positions z=z+c<s:byte(i-1) -- if the previous char is greater than the current and-1 -- the ladder goes down or 1 -- else, it goes up end for i=1,y -- iterate on the range 1..y do x=y%i<1 -- if i is a divisor of y and x+1 -- increment x or x end for i=1,13 -- iterate on the range 1..13 do -- no need to go further for the christmas numbers d=y==i^3+2i^2+2 -- if y is a christmas number and 0 -- set d or d -- else let d as it is end print(a.. -- output "Name has been" (x==#s -- if y's divisor==length of input and"nice" -- append "nice" or(d -- else, if d is not set and"" or b.. -- append "very" (z>0 -- and if the raising ladder doesn't raise and"" or b)).. -- append a second "very" r)) -- append "naughty" ``` ### Old 371 bytes solution ``` function f(s)a,b,c,d,e,r,g,s=s.." has been ","very ",0,0,0,"naughty",math.pow,s:lower()for i=1,#s do if 32<s:byte(i)then e,d=i>1 and(s:byte(i)<s:byte(i-1)and e-1 or e+1)or e,d-96+s:byte(i)end end for i=1,d do c=d%i>0 and c or c+1 end if c==#s then return a.."nice"end for i=1,13 do if g(i,3)+2g(i,2)+2==d then return a..r end end return e>0 and a..b..r or a..b..b..r end ``` Ungolfed version :) ``` function f(s) a,b,c,d,e,r,g,s=s.." has been ","very ",0,0,0,"naughty",math.pow,s:lower() for i=1,#s do if 32<s:byte(i) then --sum of the char's order in the alphabet d=d-96+s:byte(i) --raising ladder e=i>1 and(s:byte(i)<s:byte(i-1)and e-1 or e+1)or e end end for i=1,d do -- number of d's divisors c=d%i>0 and c or c+1 end if c==#s then return a.."nice" end for i=1,13 do --Christmas number are equals n^3+2n^2+2 as @Mauris said if g(i,3)+2g(i,2)+2==d then return a..r end end --is he very naughty or very very naughty? return e>0 and a..b..r or a..b..b..r end ``` [Answer] ## Seriously, 138 bytes ``` " has been ",;' @-û╗+╝╜`O8ª@-`MΣ;2┐w`iXu`Mπ╜l=`"nice"╛+.éó`╬é03┐2└3╤1x`;;⌐*⌐`MíuY3└+3┐╜Ok0)p)`p;(@)-s@)+(`╬l>Y(Xu3└"naughty"@"very "+╛+ ``` Hex Dump: ``` 2220686173206265656e20222c3b2720402d96bb2bbcbd604f38a6402d604de43b32bf7760695875604de3bd6c3d60226e69636522be2b2e82a260ce823033bf32c033d13178603b33405e29a6e7326be4604da1755933c02b33bfbd4f6b3029702960703b2840292d7340292b2860ce6c3e5928587533c02a226e6175676874792240227665727920222a2bbe2b ``` [Try It Online](http://seriouslylang.herokuapp.com/link/code=2220686173206265656e20222c3b2720402d96bb2bbcbd604f38a6402d604de43b32bf7760695875604de3bd6c3d60226e69636522be2b2e82a260ce823033bf32c033d13178603b3ba92a2aa9604da1755933c02b33bfbd4f6b3029702960703b2840292d7340292b2860ce6c3e5928587533c02a226e6175676874792240227665727920222a2bbe2b&input=AAAAA) It is hard to effectively golf this on account of how difficult complicated flow control is in Seriously. The ability to nest functions without the use of registers would help. (I imagine this could already be shortened somewhat through judicious use of stored functions, but it would result in such spaghetti code I don't have the heart to attempt it.) Explanation: ``` " has been " push this string , read input ;' @-û╗ copy, remove space, uppercase, put in reg0 +╝ put '<input> has been ' in reg1 ╜ bring back the processed input `O8ª@-`MΣ convert letters to numbers and sum ;2┐ store a copy of the sum in reg2 w`iXu`Mπ compute the number of divisors ╜l get processed input length = check if they're equal `"nice"╛+.éó`╬ if so, run this function that retrieves the list we made earlier, appends "nice", prints it, empties the stack and immediately exits é empty the stack (it contains a 1) 03┐ put a 0 in reg3 2└ call back the letter sum from reg2 3╤1x push [1,...1000] `;;⌐⌐`M plug each number into x^3+2x^2+2 í check if the letter sum is there uY make a 1 if it is not, 0 if it is 3└+3┐ add this number to reg3 ╜Ok convert the processed input into char codes 0) put a zero behind it p) pop the first char code to bottom of stack `p;(@)-s@)+(`╬ Until the list of char codes is empty, subtract each one from the previous one, accumulating the signums l turn the leftover empty list into a 0 >Y put a 1 if the accumulated signs are >=0 (not rising), else 0 (rising) (X clean up the last char code u increment to make 0 into 1 and 1 into 2 3└ bring back the value from reg3 which is 0 if only naughty, else 1 and multiply it with preceding test result; this turns a very into a very very if this test failed, but leaves plain and single very naughty alone "naughty"@ put "naughty" below the 'very' count "very "* put "", "very ", or "very very " + append the "naughty" ╛+ bring back the string in reg1 and append the constructed suffix ``` [Answer] ## Python 2, 249 bytes ``` i=input() g=[ord(c)-96for c in i.lower()if' '!=c] s=sum(g) S=0 a=g.pop() while g:b=a;a=g.pop();S+=(a<b)-(b<a) r=range(1,14+s) print i+' has been '+[['very '(1+(S<1)),''][s in[x3+2x**2+2for x in r]]+'naughty','nice'][sum(s%x<1for x in r)==len(i)] ``` ]
[Question] [ # Background Recognizing primality seems like a poor fit for (artificial) neural networks. However, the [universal approximation theorem](https://en.wikipedia.org/wiki/Universal_approximation_theorem) states that neural networks can approximate any continuous function, so in particular it should be possible to represent any finitely-supported function one desires. So let's try to recognize all the primes among the first million numbers. More precisely, because this is a programming website, let's go up to 2^20 = 1,048,576. The number of primes below this threshold is 82,025 or roughly 8%. # Challenge How small of a neural network can you find that correctly classifies all 20-bit integers as prime or not prime? For the purposes of this challenge, the size of a neural network is the total number of weights and biases required to represent it. # Details The goal is to minimize the size of a single, explicit neural network. The input to your network will be a vector of length 20 containing the individual bits of an integer, represented either with 0s and 1s or alternatively with -1s and +1s. The ordering of these can be most-significant-bit first or least-significant-bit first. The output of your network should be a single number, such that above some cutoff the input is recognized as prime and below the same cutoff the input is recognized as not prime. For example, positive might mean prime (and negative not prime), or alternatively greater than 0.5 might mean prime (and less than 0.5 not prime). The network must be 100% accurate on all 2^20 = 1,048,576 possible inputs. As mentioned above, note that there are 82,025 primes in this range. (It follows that always outputting "not prime" would be 92% accurate.) In terms of standard neural network terminology, this would likely be called overfitting. In other words, your goal is to perfectly overfit the primes. Other words one might use are that the "training set" and the "test set" are the same. This challenge does not consider the number of "trainable" or "learnable" parameters. Indeed, your network is likely to contain hard-coded weights, and the example below is entirely hard-coded. Instead, all weights and biases are considered parameters and are counted. The length of the code necessary to train or generate your neural network is not relevant to your score, but posting the relevant code is certainly appreciated. # Baseline As a baseline, it is possible to "memorize" all 82,025 primes with 1,804,551 total weights and biases. Note that this code that follows includes many things: a working example, working test code, a working definition of neural network using a known neural network library, a "hard-coded" (or at least, not "trained") neural network, and a working measurement of score. ``` import numpy as np bits = 20 from keras.models import Sequential from keras.layers import Dense from sympy import isprime # Hardcode some weights weights = [] biases = [] for n in xrange(1<<bits): if not isprime(n): continue bit_list = [(n / (1 << i))%2 for i in xrange(bits)] weight = [2bit - 1 for bit in bit_list] bias = - (sum(bit_list) - 1) weights.append(weight) biases .append(bias) nprimes = len(biases) weights1 = np.transpose(np.array(weights)) biases1 = np.array(biases ) weights2 = np.full( (nprimes,1), 1 ) biases2 = np.array( [0] ) model = Sequential() model.add(Dense(units=nprimes, activation='relu', input_dim=bits, weights=[weights1, biases1])) model.add(Dense(units=1, activation='relu', weights=[weights2, biases2])) print "Total weights and biases: {}".format( np.size(weights1) + np.size(weights2) + np.size(biases1) + np.size(biases2) ) # Evaluate performance x = [] y = [] for n in xrange(1<<bits): row = [(n / (1 << i))%2 for i in xrange(bits)] x.append( row ) col = 0 if isprime(n): col = 1 y.append( col ) x = np.array(x) y = np.array(y) model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) loss, accuracy = model.evaluate(x, y, batch_size=256) if accuracy == 1.0: print "Perfect fit." else: print "Made at least one mistake." ``` # What is a neural network? For the purposes of this challenge, we can write down a narrow but precise definition of an (artificial) neural network. For some external reading, I suggest Wikipedia on [artificial neural network](https://en.wikipedia.org/wiki/Artificial_neural_network), [feedforward neural network](https://en.wikipedia.org/wiki/Feedforward_neural_network), [multilayer perceptron](https://en.wikipedia.org/wiki/Multilayer_perceptron), and [activation function](https://en.wikipedia.org/wiki/Activation_function). A feedforward neural network* is a collection of layers of neurons. The number of neurons per layer varies, with 20 neurons in the input layer, some number of neurons in one or more hidden layers, and 1 neuron in the output layer. (There must be at least one hidden layer because primes and not-primes are not linearly separable according to their bit patterns.) In the baseline example above, the sizes of the layers are [20, 82025, 1]. The values of the input neurons are determined by the input. As described above, this will either be 0s and 1s corresponding to the bits of a number between 0 and 2^20, or -1s and +1s similarly. The values of the neurons of each following layer, including the output layer, are determined from the layer beforehand. First a linear function is applied, in a fully-connected or dense fashion. One method of representing such a function is using a weights matrix. For example, the transitions between the first two layers of the baseline can be represented with a 82025 x 20 matrix. The number of weights is the number of entries in this matrix, eg 1640500. Then each entry has a (separate) bias term added. This can be represented by a vector, eg a 82025 x 1 matrix in our case. The number of biases is the number of entries, eg 82025. (Note that the weights and biases together describe an affine linear function.) A weight or bias is counted even if it is zero. For the purposes of this narrow definition, biases count as weights even if they are all zero. Note that in the baseline example, only two distinct weights (+1 and -1) are used (and only slightly more distinct biases); nonetheless, the size is more than a million, because the repetition does not help with the score in any way. Finally, a nonlinear function called the activation function is applied entry-wise to the result of this affine linear function. For the purposes of this narrow definition, the allowed activation functions are [ReLU](https://en.wikipedia.org/wiki/Rectifier_(neural_networks)), [tanh](https://en.wikipedia.org/wiki/Hyperbolic_function#Hyperbolic_tangent), and [sigmoid](https://en.wikipedia.org/wiki/Logistic_function). The entire layer must use the same activation function. In the baseline example, the number of weights is 20 \* 82025 + 82025 \* 1 = 1722525 and the number of biases is 82025 + 1 = 82026, for a total score of 1722525 + 82026 = 1804551. As a symbolic example, if there were one more layer and the layer sizes were instead [20, a, b, 1], then the number of weights would be 20 \* a + a \* b + b \* 1 and the number of biases would be a + b + 1. This definition of neural network is well-supported by many frameworks, including [Keras](https://keras.io/#getting-started-30-seconds-to-keras), [scikit-learn](https://scikit-learn.org/stable/modules/neural_networks_supervised.html), and [Tensorflow](https://www.kaggle.com/realshijjang/tensorflow-binary-classification-with-sigmoid). Keras is used in the baseline example above, with code essentially as follows: ``` from keras.models import Sequential model = Sequential() from keras.layers import Dense model.add(Dense(units=82025, activation='relu', input_dim=20, weights=[weights1, biases1])) model.add(Dense(units=1, activation='relu', weights=[weights2, biases2])) score = numpy.size(weights1) + numpy.size(biases1) + numpy.size(weights2) + numpy.size(biases2) ``` If the weights and bias matrices are [numpy](http://www.numpy.org/) arrays, then [numpy.size](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.size.html) will directly tell you the number of entries. # Are there other kinds of neural networks? If you want a single, precise definition of neural network and score for the purposes of this challenge, then please use the definition in the previous section. If you think that "any function" looked at the right way is a neural network with no parameters, then please use the definition in the previous section. If you are a more free spirit, then I encourage you to explore further. Perhaps your answer will not count toward the narrow challenge, but maybe you'll have more fun. Some other ideas you may try include more exotic activation functions, recurrent neural networks (reading one bit at a time), convolutional neural networks, more exotic architectures, softmax, and LSTMs (!). You may use any standard activation function and any standard architecture. A liberal definition of "standard" neural network features could include anything posted on the arxiv prior to the posting of this question. [Answer] ## Trial division: score 59407, 6243 layers, 16478 neurons in total Given as a Python program which generates and validates the net. See the comments in `trial_division` for an explanation of how it works. The validation is quite slow (as in, running time measured in hours): I recommend using PyPy or Cython. All layers use ReLU (\$\alpha \to \max(0, \alpha)\$) as the activation function. The threshold is 1: anything above that is prime, anything below is composite or zero, and the only input which gives an output of 1 is 1 itself. ``` #!/usr/bin/python3 import math def primes_to(n): ps = [] for i in range(2, n): is_composite = False for p in ps: if i % p == 0: is_composite = True break if p * p > i: break if not is_composite: ps.append(i) return ps def eval_net(net, inputs): for layer in net: inputs.append(1) n = len(inputs) inputs = [max(0, sum(inputs[i] * neuron[i] for i in range(n))) for neuron in layer] return inputs def cost(net): return sum(len(layer) * len(layer[0]) for layer in net) def trial_division(num_bits): # Overview: we convert the bits to a single number x and perform trial division. # x is also our "is prime" flag: whenever we prove that x is composite, we clear it to 0 # At the end x will be non-zero only if it's a unit or a prime, and greater than 1 only if it's a prime. # We calculate x % p as # rem = x - (x >= (p << a) ? 1 : 0) * (p << a) # rem -= (rem >= (p << (a-1)) ? 1) : 0) * (p << (a-1)) # ... # rem -= (rem >= p ? 1 : 0) * p # # If x % p == 0 and x > p then x is a composite multiple of p and we want to set it to 0 N = 1 << num_bits primes = primes_to(1 + int(2.0 ** (num_bits / 2))) # As a micro-optimisation we exploit 2 == -1 (mod 3) to skip a number of shifts for p=3. # We need to bias by a multiple of 3 which is at least num_bits // 2 so that we don't get a negative intermediate value. bias3 = num_bits // 2 bias3 += (3 - (bias3 % 3)) % 3 # inputs: [bit0, ..., bit19] yield [[1 << i for i in range(num_bits)] + [0], [-1] + [0] * (num_bits - 1) + [1], [0] * 2 + [-1] * (num_bits - 2) + [1], [(-1) ** i for i in range(num_bits)] + [bias3]] for p in primes[1:]: # As a keyhole optimisation we overlap the cases slightly. if p == 3: # [x, x_is_even, x_lt_4, x_reduced_mod_3] max_shift = int(math.log((bias3 + (num_bits + 1) // 2) // p, 2)) yield [[1, 0, 0, 0, 0], [0, 1, -1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, -1, p << max_shift]] yield [[1, -N, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, -1, 1]] yield [[1, 0, 0, 0], [0, 1, -p << max_shift, 0]] else: # [x, x % old_p] max_shift = int(num_bits - math.log(p, 2)) yield [[1, 0, 0], [1, -N, -p_old], [-1, 0, p << max_shift]] yield [[1, -N, 0, 0], [0, 0, -1, 1]] yield [[1, 0, 0], [1, -p << max_shift, 0]] for shift in range(max_shift - 1, -1, -1): # [x, rem] yield [[1, 0, 0], [0, 1, 0], [0, -1, p << shift]] yield [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, 1]] yield [[1, 0, 0, 0], [0, 1, -p << shift, 0]] # [x, x % p] p_old = p yield [[1, 0, 0], [1, -N, -p]] yield [[1, -N, 0]] def validate_primality_tester(primality_tester, threshold): num_bits = len(primality_tester[0][0]) - 1 primes = set(primes_to(1 << num_bits)) errors = 0 for i in range(1 << num_bits): expected = i in primes observed = eval_net(primality_tester, [(i >> shift) & 1 for shift in range(num_bits)])[-1] > threshold if expected != observed: errors += 1 print("Failed test case", i) if (i & 0xff) == 0: print("Progress", i) if errors > 0: raise Exception("Failed " + str(errors) + " test case(s)") if __name__ == "__main__": n = 20 trial_div = list(trial_division(n)) print("Cost", cost(trial_div)) validate_primality_tester(trial_div, 1) ``` --- As an aside, re > > the universal approximation theorem states that neural networks can approximate any continuous function > > > it's easy to show that a neural network using ReLU is Turing complete. The easiest logic gate to implement robustly is NOR: an n-input NOR gate is \$\max\left(0, 1 - \sum a\_i\right)\$. I say robustly because this gate accepts inputs greater than 1 but (provided the inputs are not between 0 and 1) only ever outputs 0 or 1. A single-layer AND gate is \$\max\left(0, 1 + \sum(a\_i - 1)\right)\$ but only works correctly if its inputs are guaranteed to be 0 or 1, and may output larger integers. Various other gates are possible in one layer, but NOR by itself is Turing-complete so there's no need to go into detail. [Answer] ## Score 984314, 82027 layers, 246076 neurons in total We can keep things entirely in the integers if we use activation function ReLU, which simplifies the analysis. Given an input \$x\$ which is known to be an integer, we can test whether \$x = a\$ with two layers and three neurons: 1. First layer: outputs \$\textrm{ge}\_a = (x - a)^+\$ and \$\textrm{le}\_a = (-x + a)^+\$ 2. Second layer: outputs \$\textrm{eq}\_a = (-\textrm{ge}\_a - \textrm{le}\_a + 1)^+\$. \$\textrm{eq}\_{a}\$ will be \$1\$ if \$x = a\$ and \$0\$ otherwise. --- Layer 1: reduce the 20 inputs to one value \$x\$ with weights 1, 2, 4, ... and bias 0. Cost: (20 + 1) \* 1 = 21. Layer 2: outputs \$\textrm{ge}\_2 = (x - 2)^+\$, \$\textrm{le}\_2 = (-x + 2)^+\$. Cost (1 + 1) \* 2 = 4. Layer 3: outputs \$\textrm{accum}\_2 = (-\textrm{ge}\_2 - \textrm{le}\_2 + 1)^+\$, \$\textrm{ge}\_3 = (\textrm{ge}\_2 - (3-2))^+\$, \$\textrm{le}\_3 = (-\textrm{ge}\_2 + (3-2))^+\$. Cost (2 + 1) \* 3 = 9. Layer 4: outputs \$\textrm{accum}\_3 = (2^{21} \textrm{accum}\_2 -\textrm{ge}\_3 - \textrm{le}\_3 + 1)^+\$, \$\textrm{ge}\_5 = (\textrm{ge}\_3 - (5-3))^+\$, \$\textrm{le}\_5 = (-\textrm{ge}\_3 + (5-3))^+\$. Cost (3 + 1) \* 3 = 12. Layer 5: outputs \$\textrm{accum}\_5 = (2^{21} \textrm{accum}\_3 -\textrm{ge}\_5 - \textrm{le}\_5 + 1)^+\$, \$\textrm{ge}\_7 = (\textrm{ge}\_5 - (7-5))^+\$, \$\textrm{le}\_7 = (-\textrm{ge}\_5 + (7-5))^+\$. Cost (3 + 1) \* 3 = 12. ... Layer 82026: outputs \$\textrm{accum}\_{1048571} = (2^{21} \textrm{accum}\_{1048559} -\textrm{ge}\_{1048571} - \textrm{le}\_{1048571} + 1)^+\$, \$\textrm{ge}\_{1048573} = (\textrm{ge}\_{1048571} - ({1048573}-{1048571}))^+\$, \$\textrm{le}\_{1048573} = (-\textrm{ge}\_{1048571} + ({1048573}-{1048571}))^+\$. Cost (3 + 1) \* 3 = 12. Layer 82027: outputs \$\textrm{accum}\_{1048573} = (2^{21} \textrm{accum}\_{1048571} -\textrm{ge}\_{1048573} - \textrm{le}\_{1048573} + 1)^+\$. Cost (3 + 1) \* 1 = 4. The threshold is 0. If working with doubles, overflow to \$+\infty\$ is quite possible, but that seems to be perfectly in accordance with the rules. Score is (82026 - 3) \* 12 + 21 + 4 + 9 + 4. ]
[Question] [ I was at a friend's house for dinner and they suggested the idea of a "Prime-factor vector space". In this space the positive integers are expressed as a vector such that the nth element in the vector is the number of times the nth prime divides the number. (Note that this means that our vectors have an infinite number of terms.) For example 20 is ``` 2 0 1 0 0 0 ... ``` Because its prime factorization is *2 \ 2 \* 5. Since prime factorization is unique each number corresponds to one vector. We can add vectors by pairwise adding their entries. This is the same as multiplying the numbers they are associated with. We can also do scalar multiplication, which is akin to raising the associated number to a power. The problem is that this space is not in fact a vector space because there are no inverses. If we go ahead and add the inverses and close the vector space we now have a way of expressing every positive rational number as a vector. If we keep the fact that vector addition represents multiplication. Then the inverse of a natural number is its reciprocal. For example the number 20 had the vector ``` 2 0 1 0 0 0 ... ``` So the fraction 1/20 is its inverse ``` -2 0 -1 0 0 0 ... ``` If we wanted to find the vector associated with a fraction like 14/15 we would find 14 ``` 1 0 0 1 0 0 ... ``` and 1/15 ``` 0 -1 -1 0 0 0 ... ``` and multiply them by performing vector addition ``` 1 -1 -1 1 0 0 ... ``` Now that we have a vector space we can modify it to form an inner product space by giving it an inner product. To do this we steal the inner product that vector spaces are given classically. The inner product of two vectors is defined as the sum of the pairwise multiplication of their terms. For example 20 · 14/15 would be calculated as follows ``` 20 = 2 0 1 0 0 0 ... 14/15 = 1 -1 -1 1 0 0 ... 2 0 -1 0 0 0 ... -> 1 ``` As another example the product 2/19 · 4/19** ``` 2/19 = 1 0 0 0 0 0 0 -1 0 0 0 ... 4/19 = 2 0 0 0 0 0 0 -1 0 0 0 ... 2 0 0 0 0 0 0 1 0 0 0 ... -> 3 ``` Your task is to implement a program that performs this dot product. It should take two positive rational numbers via either a pair of positive integers (numerator and denominator) or a rational type (floats are not allowed, because they cause problems with precision and divisibility) and should output a integer representing the dot product of the two inputs. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so answers will be scored in bytes with fewer bytes being better. ## Test Cases ``` 4 · 4 = 4 8 · 8 = 9 10 · 10 = 2 12 · 12 = 5 4 · 1/4 = -4 20 · 14/15 = 1 2/19 · 4/19 = 3 ``` [Answer] # [MATL](https://github.com/lmendo/MATL), 12 bytes ``` YF2:&Y)dwds ``` Input is an array `[num1 den1 num2 den2]`. [Try it online!](https://tio.run/##y00syfn/P9LNyEotUjOlPEWr@P//aCMDBUMFQxMFQ9NYAA "MATL – Try It Online") Or [verify all test cases](https://tio.run/##y00syfmf8D/SzchKLVIzpTxFq/i/S8j/aBMFQwUgjuWKtgCyLMAsQwMgE0SA2EYgthGYDVILVA1kGYFVAPmmII6CoSXIDMtYAA). ### Explanation Consider example input `[20 1 14 15]`. ``` YF % Implicit input: array of 4 numbers. Exponents of prime factorization. % Gives a matrix, where each row corresponds to one of the numbers in % the input array. Each row may contain zeros for non-present factors % STACK: [2 0 1 0 0 0 0 0 1 0 0 1 0 1 1 0] 2:&Y) % Push a submatrix with the first two rows, then a submatrix with the % other two rows % STACK: [2 0 1 0 0 0 0 0], [1 0 0 1 0 1 1 0] d % Consecutive difference(s) along each column % STACK: [2 0 1 0 0 0 0 0], [-1 1 -1 1] wd % Swap, and do the same for the other submatrix % STACK: [-1 1 -1 1] [-2 0 -1 0] % Element-wise product % STACK: [2 0 -1 0] s % Sum. Implicit display % STACK: 1 ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), 99+32 = 131 bytes * Using a compiler flag requiring 32 bytes, `-D=F(v,V,e)for(;v%p<1;V+=e)v/=p;`. ``` T,p,A,C;f(a,b,c,d){T=0;for(p=2;a+b+c+d>4;p++){A=C=0;F(a,A,1)F(b,A,~0)F(c,C,1)F(d,C,~0)T+=AC;}a=T;} ``` [Try it online!](https://tio.run/##bZFNasMwEEbX7SlEICBVk9ojlIVRFDAuPoHJqhtbjkKgdURavDHu0etKdn/s0M08MdJjvkFmczJmGApwkEKmLC2hAgM16wodK3u5UqeFKnnFDa/3UjnOWZfqzF/m/m0KyHJaeX7E/mAgGxu1p28UXKcPmepLXah@eC3PDWXd/Z27npt3S1dERgTJI5mo92RdPzcrsJRIIAhjZUz9CRhPwsSZgHEQxroUxLcgbgUxCuJW@I2EEZH/RAqpFoL4iSQj3M4FMUWSgNvlBBFhMi3tOZ8gAJOwNCZB6IdPY1/K09uwedI5beEARxb@Q7Vrt0N14PrI2kg79QU "C (gcc) – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~12~~ 11 bytes ``` ÆEz0_2/€P€S ``` [Try it online!](https://tio.run/##y0rNyan8//9wm2uVQbyR/qOmNQFAHPz/cDuQivz/P5pLIdpER8FQRwFExuoAuRZgrgWMa2gA5oMpiIARRMAIJgDRDzICzDWCagAJm8ZyxQIA "Jelly – Try It Online") [Answer] # [Python 2](https://docs.python.org/2/), 110 bytes ``` l=input() p=t=2 while~-max(l):r=i=0;exec"while l[i]%p<1:l[i]/=p;r+=1ji\ni+=1\n"4;t+=rr;p+=1 print t.imag/2 ``` [Try it online!](https://tio.run/##HY1BDoIwEEX3PQUhMYGCYhs2UuckwIKYRsaUMpmMETdeHavJW7y8v/j0lnmNdt8DYKSnFKUiELDqNWPwn@MybUUoOwaEs/Obv@X/IQs9jge6mu4nDZDjCsxDaxwiJhtirlsnFbBmRykoYoySyQmX6d6kv97WbW0uifEL "Python 2 – Try It Online") Takes input like `[num1, num2, den1, den2]`. Uses a complex number `r` to store the entries for prime `p` for the two rationals, and `(rr).imag/2` to extract their product `r.realr.imag` within overall the sum `t`. Adding `1ji` for `i=0,1,2,3` does each combination of incrementing or decrementing the real or imaginary part for the four input numbers. Bubbler saved 2 bytes combining the initial values `p=t=2`.* [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 55 bytes ``` Dot@@PadRight[SparseArray[Rule@@@FactorInteger@#]&/@#]& ``` [Try it online!](https://tio.run/##HYvNCoMwEIRfZVHwlBIjFuyhsoVS6E3sMXhYbPyBqiXdHor47GniZeYbZmYiHsxEPLbkOjiDuy6MWNGzHvuB9eNN9mMu1tJP19@XQcQbtbzY@8ymNxbjJpFBXGXHmXUsIIJDCZGATsdNAwlIhHXNBeSbgLUQUARXqQCV7pR5ygL5jZL7KgttLtVxD1Kd/Nvrtrk/ "Wolfram Language (Mathematica) – Try It Online") [Answer] # [JavaScript (Node.js)](https://nodejs.org), ~~104~~ ... ~~100~~ 94 bytes ``` F=(A,i=2)=>A.some(x=>x>1)&&([a,b,c,d]=A.map(G=(x,j)=>x%i?0:1+G(A[j]/=i,j)),a-b)(c-d)+F(A,i+1) ``` [Try it online!](https://tio.run/##bc7NDoIwDAfwu@8h6aQgWzQBzTC7wEMQDuMjZgQYEWP29nPzaHZoD/3903aSH7n3L7W9k1UPo7UVB4GKM8JLke56GcHw0pSURBE0EjvscWi5SBe5Qc3B4OSS5qge2Y3GNYhmas9cuSlBmXTkBH0ykLjyS2NK7L3X667nMZ31EypoLkjRVUvI4Z9yR3mYaObMtyAyjyyM/p67GCL2W@oC16AiLfynhUP7BQ "JavaScript (Node.js) – Try It Online") Pass the numbers as an array of [Num1, Den1, Num2, Den2]. Thanks for Arnauld for fixing the missing `F=` with no extra bytes, and 2 more bytes less. ## Explanation & ungolfed ``` function F(A, i = 2) { // Main function, recursing from i = 2 if (A.some(function(x) { // If not all numbers became 1: return x > 1; })) { var B = A.map(G = function(x, j) { // A recursion to calculate the multiplicity if (x % i) return 0; else return 1 + G(A[j] /= i, j); // ...and strip off all powers of i }); return (B[0] - B[1]) (B[2] - B[3]) // Product at i + F(A, i + 1); // Proceed to next factor. All composite factors } // will be skipped effectively else return 0; // Implied in the short-circuit && } ``` [Answer] # [J](http://jsoftware.com/), 19 bytes ``` 1#./@,:&([:-/_&q:) ``` [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/DZX1tPQddKzUNKKtdPXj1QqtNP9rcilwpSZn5CuYKBgqpIFICNcCzLWAcQ0NwHwQBRUwgggYwQQg@g0VTCBcI6gGoLApVETB0BJmhyUX138A "J – Try It Online") ## Explanation: A dyadic verb, arguments are on both left hand and right hand side ``` &( ) - for both arguments (which are lists of 2 integers) _&q: - decompose each number to a list of prime exponents [:-/ - and find the difference of these lists ,: - laminate the resulting lists for both args (to have the same length) /@ - multiply them 1#. - add up ``` [Answer] # [Stax](https://github.com/tomtheisen/stax), 11 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax) ``` ä÷ß½♂←√:=Ü] ``` [Run and debug it](https://staxlang.xyz/#c=%C3%A4%C3%B7%C3%9F%C2%BD%E2%99%82%E2%86%90%E2%88%9A%3A%3D%C3%9C%5D&i=%5B4%2C1%2C+4%2C1%5D%0A%5B8%2C1%2C+8%2C1%5D%0A%5B10%2C1%2C+10%2C1%5D%0A%5B12%2C1%2C+12%2C1%5D%0A%5B4%2C1%2C+1%2C4%5D%0A%5B20%2C1%2C+14%2C15%5D%0A%5B2%2C19%2C+4%2C19%5D&a=1&m=2) The corresponding ascii representation of the same program is this. ``` {\|nmMFE-~-,+ ``` Basically, it gets the prime factorization's exponents for each part. It takes the difference of each pair, then the product, and finally sums all the results. [Answer] # [Python 2](https://docs.python.org/2/), 133 127 bytes ``` a=input();s=0;p=2;P=lambda n,i=0:n%p and(n,i)or P(n/p,i+1) while~-max(a):a,(w,x,y,z)=zip(map(P,a));s+=(w-x)(y-z);p+=1 print s ``` [Try it online!](https://tio.run/##Hc7BioMwEAbgu08xsCwmGlmTtWCUvIP30kO2Bhqo6dBajB766u7EwwzfDzPD4DrfHkHtLrprnue7NT7ge2a8f5m6R6P6wdzt9DdaCMKbugvfCDaMjBJ/PGFg4QeFLyXPlpu/u0812cgs76xgi4hiFRs3m0dWTBbZICyny6VhSxV5wdZq4z2WRmb49GGG104/QAFt9gUuorvObuygAU2l4ARVAxJ@93MjpKC6ZOeW1B7SJH1I1sTUklWyOpy2aI@kjgnKpxSE1OmavvwD "Python 2 – Try It Online") Stole the loop condition from [xnor's submission](https://codegolf.stackexchange.com/a/156598/78410). Thanks for the advice by @mathmandan to change the function into a program (Yes, it indeed saved some bytes). Obsolete, incorrect solution (124 bytes): ``` lambda w,x,y,z:sum((P(w,p)-P(x,p))(P(y,p)-P(z,p))for p in[2]+range(3,w+x+y+z,2)) P=lambda n,p,i=1:n%p and i or P(n/p,p,i+1) ``` [Answer] # [Haskell](https://www.haskell.org/), 153 bytes ``` (2%) n%m\|all(<2)m=0\|(k,[a,b,c,d])<-unzip[(,)=<<div x.max 1.(n)$until((>0).mod x.(n^))(+1)1-1\|x<-m]=(a-b)(c-d)+[i\|i<-[n..],all((>0).rem i)[2..i-1]]!!1%k ``` [Try it online!](https://tio.run/##LY1NTsMwEEb3PsUgUclubTdjUimREjaskbpEMkZymxasxqbqD6ognIs9ByPYSRcevzeez/Nmj7tN2/bb@rmnasJImPjOti2tFPN11tEd15av@Jo3hlXiHD7dXlPO6qpq3AdcpLcXQEnDlN2ew8m1lN5nTPr3Jr7R8MIYnSFDgd2lEt7U1IoVm9K1aNhMu85VQgcpDU8rh@Rh48ExraR0Ao25ucHJrvfWBajB2/0j0P3BhRNI2DLQBHTOkcdjeOQicnFlzKKkMppKpq6WMjE1sBrmYmcxKscy/VcaQ8iXIDn8/kAel@ekSFhELAlmiWOtQRFUg6goi3Ee5ykhcqLGuXyOi9hAouZYDh@mu4Y7Ir77v/W2ta/HXjw9LJf/ "Haskell – Try It Online") Example usage for `20 · 14/15`: `(2%) [20,1,14,15]`. ]
[Question] [ Poker hands are ranked from best to worst as follows: 1. Straight flush - five cards of sequential rank, all of the same suit 2. Four of a kind - four cards of the same rank and one card of another rank 3. Full house - three cards of one rank and two cards of another rank 4. Flush - five cards all of the same suit 5. Straight - five cards of sequential rank 6. Three of a kind - three cards of the same rank and two cards of two other ranks 7. Two pair - two cards of the same rank, two cards of another rank and one card of a third rank 8. One pair - two cards of the same rank and three cards of three other ranks 9. High card - five cards not all of sequential rank or of the same suit, and none of which are of the same rank * Rank = The number on the card (A, K, Q, J, 10, 9, 8, 7, 6, 5, 4, 3, 2). You may choose to use T instead of 10. * Suit = hearts (h), spades (s), clubs (c) and diamonds (d). Note that the Ace, `A`, can both be the highest and the lowest number (1 or 14). A card can be identified by two letters `As` (Ace of spades), `Jc` (Jack of clubs), `7h` (7 of hearts) and so on. --- ### Challenge: You get four cards from the dealer (four input strings). Find and output the best possible last card you can get. If there are cards that are equally good then you can choose which to pick. Input and output formats are optional, but the individual cards must identified as shown above `Jc` and `2h`. --- ### Test cases: ``` Ah Kh Jh 10h Qh 7d 8h 10c Jd 9d (or 9h, 9c, 9s) Js 6c 10s 8h Jc (or Jh, Jd) Ac 4c 5d 3d 2h (or 2d, 2c, 2s) 5s 9s Js As Ks 2h 3h 4h 5h 6h Js Jc Ac Ah As (or Ad) <- Note that AAAJJ is better than AAJJJ because A is higher than J 10d 9d 5h 9c 9h (or 9s) Ah Ac Ad As Ks (or Kd, Kh, Kc) 4d 5h 8c Jd Jc (or Js, Jh) ``` This is code golf, so the shortest submission in bytes win. [Answer] # Pyth, 73 bytes ``` eo_S+-5l@\AN}SPMJ+NZSM.:+\AT5+-4l{eMJlM.gPkJ-sM=T+`M}2Tc4"JQKA""hscd"=Zc ``` This is pretty terrible. Parsing cards, sorting the values, ... Everything takes so many chars. But the approach is interesting. Try it online: [Demonstration](http://pyth.herokuapp.com/?code=eo_S%2B%2a-5%2FN%5CA%7DSPMJ%2BNZSM.%3A%2B%5CAT5%2B-4l%7BeMJlM.gPkJ-sM%2a%3DT%2B%60M%7D2Tc4%22JQKA%22%22hscd%22%3DZc&input=%227d+8h+10c+Jd%22&test_suite=0&test_suite_input=%22Ah+Kh+Jh+10h%22%0A%227d+8h+10c+Jd%22%0A%22Js+6c+10s+8h%22%0A%22Ac+4c+5d+3d%22%0A%225s+9s+Js+As%22%0A%222h+3h+4h+5h%22%0A%22Js+Jc+Ac+Ah%22%0A%2210d+9d+5h+9c%22%0A%22Ah+Ac+Ad+As%22%0A%224d+5h+8c+Jd%22&debug=0) or [Test Suite](http://pyth.herokuapp.com/?code=eo_S%2B%2a-5%2FN%5CA%7DSPMJ%2BNZSM.%3A%2B%5CAT5%2B-4l%7BeMJlM.gPkJ-sM%2a%3DT%2B%60M%7D2Tc4%22JQKA%22%22hscd%22%3DZc&input=%227d+8h+10c+Jd%22&test_suite=1&test_suite_input=%22Ah+Kh+Jh+10h%22%0A%227d+8h+10c+Jd%22%0A%22Js+6c+10s+8h%22%0A%22Ac+4c+5d+3d%22%0A%225s+9s+Js+As%22%0A%222h+3h+4h+5h%22%0A%22Js+Jc+Ac+Ah%22%0A%2210d+9d+5h+9c%22%0A%22Ah+Ac+Ad+As%22%0A%224d+5h+8c+Jd%22&debug=0) ### Explanation: I generate all 52 cards, remove the four cards of the input, generate a score for each card (score of the hand), and print the card with the maximal score. The score is a little bit odd. If I compare the score of two completely different hands, it may pick the wrong winner. E.g. a straight would beat 4 aces. But it works, if the first 4 cards are the same in both hands. And my computed score is actually not a value, but a list of values: * G: First I group the 5 cards by rank and take the lengths: `5h 5d 6c 5s Jd` `->` `[3, 1, 1]` * F: Then I append 4 minus the number of different suites to this list. `Flush` `->` `3` gets appended, `not flush` `->` `2/1/0` gets appended. * S: Add another number. `0` if it is not a straight, `4` if it is the straight `A2345`, or `5` if it is a higher straight. These lists of 4-7 numbers get sorted in decreasing order and the list with maximal value is picked. Why does this work? Here you see the possible configurations for all types. The letter beside the numbers, tell you with which rule this number got generated. * Straight flush: `[5S, 3F, 1G, 1G, 1G, 1G, 1G]` or `[4S, 3F, 1G, 1G, 1G, 1G, 1G]` * Four of a kind: `[4G, 1G, 0F, 0S]` * Full house: `[3G, 2G, 1F, 0S]` or `[3G, 2G, 0F, 0S]` * Flush: `[3F, 1G, 1G, 1G, 1G, 1G, 0S]` * Straight: `[5S, 2F, 1G, 1G, 1G, 1G, 1G]`, `[5S, 1F, 1G, 1G, 1G, 1G, 1G]`, `[5S, 1G, 1G, 1G, 1G, 1G, 0F]`, `[4S, 2F, 1G, 1G, 1G, 1G, 1G]`, `[4S, 1F, 1G, 1G, 1G, 1G, 1G]`, `[4S, 1G, 1G, 1G, 1G, 1G, 0F]` * Three of a kind: `[3G, 1G, 1G, 1F, 0S]`, `[3G, 1G, 1G, 0F, 0S]` * Two pair: `[2G, 2G, 2F, 1G, 0S]`, `[2G, 2G, 1F, 1G, 0S]`, `[2G, 2G, 1G, 0F, 0S]` * One pair: `[2G, 2F, 1G, 1G, 1G, 0S]`, `[2G, 1G, 1G, 1G, 1F, 0S]`, `[2G, 1G, 1G, 1G, 0F, 0S]` * High card: `[2F, 1G, 1G, 1G, 1G, 1G, 0S]`, `[1F, 1G, 1G, 1G, 1G, 1G, 0S]`, `[1G, 1G, 1G, 1G, 1G, 0S, 0F]` Pyth compares lists element-wise. So it's obvious that a Straight flush will always beat Four of a kind. Most of the typical poker rules are obvious with these lists. Some seem conflicting. * A Straight will win against Four of a kind or a Full house: Not a problem. If you have a chance to get Four of a kind / Full house with the river card, than you can't reach a straight at the same time (since you already have 2 or 3 different suites in your hand). * A Straight will win against a flush. If you can reach a flush and a straight with the river card, then you also can reach a straight flush. And the straight flush has a better score than both the straight and the flush. * One pair `[2G, 2F, 1G, 1G, 1G, 0S]` will win against some two pair hands. Also no problem. If you get a two pair with the river card, than you had at least one pair before the river. But this means, that you can improve to three of a kind, which is better. So a two pair will actually never be the answer. * High card `[2F, 1G, 1G, 1G, 1G, 1G, 0S]` will win against some one pair hands. If this is the best score you can reach, before the river you will have 3 cards of one suite and one card of a different suite. But then you can choose the card with one of these two suites and with a value that already appears, and you'll end up with the score `[2F, 2G, ...]`, which is also better. So this chooses the correct type of solution. But how do I get the best one-pair (out of 4 possibilities), how do I choose the best straight, ...? Because two different one-pair solutions can have the same score. That's easy. Pyth guaranties stable sorting (when taking the maximum). So I simple generate the cards in the order `2h 2s 2c 2d 3h 3s ... Ad`. So the card with the highest value will automatically be the maximum. ### Implementation details `=Zc` splits the input string and stores the list of cards in `Z`. `=T+`M}2Tc4"JQKA"` generates the list of ranks `['2', ..., '10', 'J', 'Q', 'K', 'A']` and stores them in `T`. `-sMT..."hscd"Z` generates each combination of rank with the suites, and removes the cards of `Z`. `o...` orders these remaining cards by: `lM.gPkJ` the lenght of the groups of the ranks, `+-4l{eMJlM` appends 4 - length(suites), `+-5l@\AN}SPMJ+NZSM.:+\AT5` appends 0/4/5 depending on suite (generate each substring of length 5 of "A"+T, check if the hand one of them (requires sorting the hand and sorting all subsets), multiply by 5 - number of "A"s in the card), `_S` sorts the list decreasing. `e` pick the maximum and print. [Answer] ## JavaScript (ES6), ~~329~~ ~~324~~ ~~317~~ ~~312~~ 309 bytes ``` H=>[..."cdhs"].map(Y=>[...L="AKQJT98765432"].map(X=>~H.indexOf(X+=Y)\|\|([...H,X].map(([R,S])=>a\|=eval(S+'\|=1<<L.search(R)',F\|=S!=H[0][1]),F=a=c=d=h=s=0),x=c\|d,y=h\|s,c&=d,h&=s,p=c\|x&y\|h,t=c&y\|h&x,(S=a-7681?((j=a/31)&-j)-j?F?c&h?2e4+a:t?t^p?3e4+t:7e4:p?8e4+p:M:4e4+a:F?5e4+a:a:F?6e4:1e4)<M&&(R=X,M=S))),M=1/0)&&R ``` ### How it works For each remaining card in the deck, we compute a hand score `S`. The lower the score, the better the hand. Variables used to compute the score * `F`: falsy if the hand is a flush * `c`: bitmask of Clubs * `d`: bitmask of Diamonds * `h`: bitmask of Hearts * `s`: bitmask of Spades * `x = c \| d`: bitmask of Clubs OR Diamonds * `y = h \| s`: bitmask of Hearts OR Spades * `a`: bitmask of all combined suits * `p = c & d \| x & y \| h & s`: pair bitmask (1) * `t = c & d & y \| h & s & x`: three of a kind bitmask (1) (1) I wrote these formulas some years ago and used them in several poker engines. They do work. :-) Other formulas * `c & d & h & s`: four of a kind bitmask * `a == 7681`: test for the special straight "A, 2, 3, 4, 5" (0b1111000000001) * `((j = a / 31) & -j) == j`: test for all other straights Score chart ``` Value \| Hand ---------+-------------------------------------------- 0 + a \| Standard Straight Flush 1e4 \| Special Straight Flush "A, 2, 3, 4, 5" 2e4 + a \| Four of a Kind 3e4 + t \| Full House 4e4 + a \| Flush 5e4 + a \| Standard Straight 6e4 \| Special Straight "A, 2, 3, 4, 5" 7e4 \| Three of a Kind 8e4 + p \| Pair Max. \| Everything else ``` NB: We don't have to care about Two-Pair which can't possibly be our best option. (If we already have one pair, we can turn it into a Three of a Kind. And if we already have two pairs, we can turn them into a Full House.) ### Test cases ``` let f = H=>[..."cdhs"].map(Y=>[...L="AKQJT98765432"].map(X=>~H.indexOf(X+=Y)\|\|([...H,X].map(([R,S])=>a\|=eval(S+'\|=1<<L.search(R)',F\|=S!=H[0][1]),F=a=c=d=h=s=0),x=c\|d,y=h\|s,c&=d,h&=s,p=c\|x&y\|h,t=c&y\|h&x,(S=a-7681?((j=a/31)&-j)-j?F?c&h?2e4+a:t?t^p?3e4+t:7e4:p?8e4+p:M:4e4+a:F?5e4+a:a:F?6e4:1e4)<M&&(R=X,M=S))),M=1/0)&&R console.log(f(["Ah", "Kh", "Jh", "Th"])); // Qh console.log(f(["7d", "8h", "Tc", "Jd"])); // 9d (or 9h, 9c, 9s) console.log(f(["Js", "6c", "Ts", "8h"])); // Jc (or Jh, Jd) console.log(f(["Ac", "4c", "5d", "3d"])); // 2h (or 2d, 2c, 2s) console.log(f(["5s", "9s", "Js", "As"])); // Ks console.log(f(["2h", "3h", "4h", "5h"])); // 6h console.log(f(["Js", "Jc", "Ac", "Ah"])); // As (or Ad) console.log(f(["Td", "9d", "5h", "9c"])); // 9h (or 9s) console.log(f(["Ah", "Ac", "Ad", "As"])); // Ks (or Kd, Kh, Kc) console.log(f(["4d", "5h", "8c", "Jd"])); // Jc (or Js, Jh) ``` [Answer] # JavaScript (ES6), 307 ~~349~~ This is quite bulky and I'm not sure it's the best approach. ~~Still a little golfable perhaps.~~ ``` h=>(r='_23456789TJQKAT',R=x=>r.search(x[0]),M=i=>[...'hcds'].some(s=>h.indexOf(j=h[i][0]+s)<0)&&j,[u,v,w,y]=h.sort((a,b)=>R(a)-R(b)).map(x=>R(x)),[,,d,e,f,g,k]=[...new Set(h+h)].sort(),q=10-u-v-w,s=(z=y>12)&q>0?q:y-u<5&&u5+q-y,d>r?z?'Kh':'Ah':f>r?M((e>r?v<w:u<v)+1):s?r[s]+g:k?M(3):r[13-z-(w>11)-(v>10)]+g) ``` Less golfed* ``` h=>( // card rank, 1 to 13, 0 unused // fake rank 14 is T, to complete a straight JQKA? // as I always try to complete a straight going up r = '_23456789TJQKAT', // R: rank a card R = x => r.search(x[0]), // M: find a missing card (to complete a same-rank set like a poker) // look for a card with the same rank of the card at position i // but with a suit not present in the hand M = i => [...'hcds'].some(s => h.indexOf(j=h[i][0]+s) < 0) && j, h.sort((a, b) => R(a)-R(b) ), // sort hand by rank [u,v,w,y] = h.map(x=>R(x)), // rank of cards 0..3 in u,v,w,y // Purpose: look for duplicate rank and/or duplicate suits // Put values and suits in d,e,f,g,k, with no duplicates and sorted // suits are lowercase and will be at right end [,,d,e,f,g,k] = [...new Set(h+h)].sort(), // Only if all ranks are different: find the missing value to get a straight // or 0 if a straight cannot be obtained // The first part manages the A before a 2 q = 10-u-v-w, s = y>12&q>0 ? q : y - u < 5 && u * 5 + q - y, d > r // d is lowercase -> all cards have the same rank ? u < 13 ? 'Ah' : 'Kh' // add a K to a poker of A, else add an A : e > r // e is lowercase -> 2 distinct ranks ? M(v<w ? 2 : 1) // go for a poker or a full house : f > r // f is lowercase -> 3 distinct ranks, we have a pair ? M(u<v ? 2 : 1) // find the pair and go for 3 of a kind : s // all different ranks, could it become a straight? ? r[s] + g // if there is only a suit, it will be a flush straight too : k // if there are 2 or more different suits ? M(3) // go for a pair with the max rank : r[13-(y>12)-(w>11)-(v>10)]+g // flush, find the max missing card ) ``` Test ``` F= h=>(r='_23456789TJQKAT',R=x=>r.search(x[0]),M=i=>[...'hcds'].some(s=>h.indexOf(j=h[i][0]+s)<0)&&j,[u,v,w,y]=h.sort((a,b)=>R(a)-R(b)).map(x=>R(x)),[,,d,e,f,g,k]=[...new Set(h+h)].sort(),q=10-u-v-w,s=(z=y>12)&q>0?q:y-u<5&&u*5+q-y,d>r?z?'Kh':'Ah':f>r?M((e>r?v<w:u<v)+1):s?r[s]+g:k?M(3):r[13-z-(w>11)-(v>10)]+g) output=x=>O.textContent+=x+'\n' ;`Ah Kh Jh Th -> Qh 7d 8h Tc Jd -> 9d 9h 9c 9s Js 6c Ts 8h -> Jc Jh Jd Ac 4c 5d 3d -> 2h 2d 2c 2s 5s 9s Js As -> Ks 2h 3h 4h 5h -> 6h Js Jc Ac Ah -> As Ad Td 9d 5h 9c -> 9h 9s Ah Ac Ad As -> Ks Kd Kh Kc 4d 5h 8c Jd -> Jc Js Jh` .split('\n') .forEach(s=>{ var o = s.match(/\w+/g) // input and output var h = o.splice(0,4) // input in h, output in o var hs = h+'' var r = F(h) var ok = o.some(x => x==r) output((ok?'OK ':'KO ')+ hs + ' -> ' + r) }) ``` ``` <pre id=O></pre> ``` ]
[Question] [ Given a description of the base state of a recursive ASCII pattern, output an expanded state somewhere along the recursion steps. More specifically: Let the following be an example: ``` ##.. ##.. ..__ ..__ ``` Where `#` is filled, `.` is empty, and `_` is recursive. This describes a pattern wherein the top left quarter is filled, the top right and bottom left are empty, and the bottom right repeats the current pattern. More rigorously, the pattern is a grid containing some number of `#`, `.`, and `_`. The grid will always be rectangular, and there will be at least one `_` and all `_` will be in a rectangular sub-grid such that the overall grid's `(width, height)` is an integer multiple of the sub-grid's `(width, height)`. Your task is, given such a pattern and a number of steps, build up an expanded form of this pattern. That is, each step, expand the grid by `n` times (where `n` is the ratio between the recursive sub-grid and the overall grid), and fill the `_` sub-grid with the pattern. At the end, fill the base-state `_` all with `#` or `.` - you choose which, but it must all be the same, and it must be consistently one or the other no matter the input. To be VERY rigorous, `f(g, n)` where `f` is this challenge, `g` is the pattern grid, and `n` is the number of steps, then `f(g, 0) == g` (with the `_` replaced by `#` OR `.`), and `f(g, n)` is the grid scaled up by `r ** n` times (where `r` is the ratio of the pattern to the recursive sub-grid), with `_` replaced by `f(g, n - 1)`. Let's do an example: ``` #. ._ 3 ``` At 0 steps, the grid is this: ``` #. ._ ``` At 1 step, the grid is this: ``` ##.. ##.. ..#. ..._ ``` At 2 steps, the grid is this: ``` ####.... ####.... ####.... ####.... ....##.. ....##.. ......#. ......._ ``` At 3 steps, the grid is this: ``` ########........ ########........ ########........ ########........ ########........ ########........ ########........ ########........ ........####.... ........####.... ........####.... ........####.... ............##.. ............##.. ..............#. ..............._ ``` Then, your output can either replace the `_` with `.` or `#`, but again, all `_` must become the same in the final output, and you must always fill it with `.` or `#` no matter the input. # Examples The `_` are shown in this output - you are to replace them with `#` or `.`, by choice. They are simply shown as `_` just to reduce confusion as to where the `_` were and where pre-filled `#` and `.` are meant to be. ``` #.#. .__# #__. .#.# 2 ``` becomes ``` ####....####.... ####....####.... ####....####.... ####....####.... ....##..##..#### ....##..##..#### ......#.#.###### .......__####### #######__....... ######.#.#...... ####..##..##.... ####..##..##.... ....####....#### ....####....#### ....####....#### ....####....#### ``` (Just gonna put this out there - this is NOT what I thought it would look like AT ALL) A non-square non-double example: ``` ##. ##. ##. ##. .#_ .#_ 2 ``` becomes ``` ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... ##################......... .........###############... .........###############... .........###############... .........###############... .........###############... .........###############... .........###############... .........###############... .........###############... .........###############... .........###############... .........###############... .........#########...#####. .........#########...#####. .........#########...#####. .........#########...#####. .........#########...###.#_ .........#########...###.#_ ``` Last example. ``` #__# .##. 3 ``` becomes ``` ###############__############### ##############.##.############## ############..####..############ ############..####..############ ########....########....######## ########....########....######## ########....########....######## ########....########....######## ........################........ ........################........ ........################........ ........################........ ........################........ ........################........ ........################........ ........################........ ``` # Rules and Specifications Input requires a grid and an integer. This grid can be taken in any reasonable, convenient format, and you can replace the characters with any three consistent, distinct values. These can be integers too, for example. Output requires a grid. This grid can be given in any reasonable, convenient format, and you can replace the characters with any two consistent, distinct values. These do not have to be the same as the ones corresponding to the inputs (why???). Standard loopholes apply. This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge, so the shortest program in bytes for each language wins. No answer will be accepted. Happy golfing! [Answer] # [MATL](https://github.com/lmendo/MATL), ~~33~~ ~~30~~ ~~27~~ 26 bytes ``` ii:"l1G1=aYm/t&Y"1Gy1=(]Zc ``` Input is a numerical matrix with `0` for empty, `9` for filled and `1` for recursive. Replaces recursive by filled at the end. Output is a character matrix with (space) for empty and `#` for filled. [Try it online!](https://tio.run/##y00syfn/PzPTSinH0N3QNjEyV79ELVLJ0L3S0FYjNir5//9oSwUDBSC2BlKGQGhpDeSBGGARsGQslxEA) Or [verify all test cases](https://tio.run/##y00syfmf8D8z00opx9Dd0DYxMle/RC1SydC90tBWIzYq@b9BcoRLVEXI/2hLBQMFILYGUoZAaGkN5IEYYBGwZCyXERdQGVgRVgqkzhBKQRVDjTKAKInlMgYA). ### Explanation ``` i % Take first input: matrix, M. This will be grown recursively i % Take second input: number, n : % Range [1 2 ... n] " % For each l % Push 1 1G % Push first input, M 1= % Compare with 1 a % Any. This gives a vector with 1 for columns that contain % at least a 1 in input M, and 0 otherwise Ym % Mean. This gives the proportion of columns with 1 / % Divide 1 by that. This gives the ratio r referred to in the challenge t % Duplicate &Y" % Repeat elements. This enlarges the current matrix by r along each dimension 1G % Push input M again y % Puesh a copy of the current enlarged matrix 1= % Compare with 1. Gives a logical mask ( % Write M into the positions indicated by that mask ] % End Zc % Convert nonzeros to character '#' and zeros to space. Implicitly display ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~32~~ 28 bytes ``` ³,Z¬ÆmṀ$€İḞ¤xZ¥ƒYṣ0ż³F¤FỴµ¡! ``` [Try it online!](https://tio.run/##AVQAq/9qZWxsef//wrMsWsKsw4Zt4bmAJOKCrMSw4biewqR4WsKlxpJZ4bmjMMW8wrNGwqRG4bu0wrXCoSH/w4dZ//9bMSwwLDAsMV0sWzIsMSwxLDJd/zM "Jelly – Try It Online") A full program that takes two arguments, a matrix of integers (0-2) and the number of steps and returns a matrix of integers (1-2). 0 is used for the recursive bit. Thanks to @JonathanAllan for saving two bytes! ## Explanation (outdated) ``` µ¡ \| Repeat the following the number of times indicates by the right argument ¤ \| - Following as a nilad: ³ \| - Original left argument (matrix of integers) ,Z \| - Paired with itself transposed Ɗ€ \| - For each of the pair, do the following as a monad: ¬ \| - Not ẸƇ \| - Keep only those with any True values F \| - Flatten Ɗ \| - Following as a monad: L \| - Length : \| - Divided by (integer) S \| - Sum ¥ƒ \| - Reduce using the argument to this iteration as the initial argument and the following as a dyad: x \| - Repeat that many times Z \| - Transpose Y \| Join with newlines ṣ0 \| - Split at zeros ż ¤ \| - Zip with the following as a nilad: ³ \| - Original left argument F \| - Flattened F \| - Flatten Ỵ \| - Split at newlines !\| Factorial (0 becomes 1) ``` [Answer] # [Python 2](https://docs.python.org/2/), ~~250~~ ~~249~~ ~~280~~ ~~266~~ ~~250~~ 248 bytes ``` def f(p,n): s=p;Q=L(p[0]) for z in R(n):u,y=[(Q/r.count('_'),y)for y,r in enumerate(s)if'_'in r][0];s=[''.join(s[j/u][i/u]for i in R(uL(s[0]))).replace('_'Q,p[(j-yu)%L(p)])for j in R(uL(s))] return[c.replace('_','#')for c in s] R=range;L=len ``` [Try it online!](https://tio.run/##ZZFLbsMgEIbX5RRIVgUTUdI4WSXiBtkkW4qsyMUpVooRNgv38u5gK1IkL4aB@b95AGEcfjpfTtO3bWjDg/BwJLRX4XRRZx70pwFCmy7SP@o8vXKUkxiV5pdtlHWX/MBZxUCMkKFRxIxZn35tvA2W9@Aa1DEWDdY69UozJtvOed7rdpuMdrjkVLfUT5szKtgVQEYbHrfa5gabiwiatx/jJsE7zgVm7te@JAEYQqMdUvS6fs0VrGAzXWe6N@Sq4s3f7emsHtZPYacYY4UkskIv@/BweKcvz4CQUC7arFYFKaoKd3hek/uZRPDVZFFlW9OHmc4lJXIrPU@LX5Hn1TzsxB4ED6Uos9sv7oBBcyRvITo/0Jy3PGuAZ8yvxeWDn8T0Dw "Python 2 – Try It Online") Input and output are both lists of strings. [Answer] # [Japt](https://github.com/ETHproductions/japt), 35 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) ``` Ê/Uèø0 NÌÆ=c@VÇXmpV r0@NÎ¬gT° ®r0Q ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=CsovVej4MApOzMY9Y0BWx1htcFYgcjBATs6sZ1SwCq5yMFE&input=WyciLicsJy4wJ10KMAotUg) ]
[Question] [ ## Input: 1. You get a series of integers (fed via stdin or prompt). 2. Every pair of integers in this series represents a building's WIDTH [valid range: 1..10] and HEIGHT [valid range: 0..10] 3. Assume input to be well-formed. Sample input (the second line is for demonstration purposes only): ``` 1 2 1 1 1 0 2 4 1 3 1 2 2 1 W H W H W H W H W H W H W H ``` Corresponding sample output: ``` ______ /______ /\| \| \| \|__ \| \|/__ /\| __ \| \| \| \|__ /__ /\| \| \| \|/__ /\| \| \| \|__ \| \| \| \| \|______ \| \|/__ /\| \| \| \| \|/______ /\| \| \| \| \|_\| \| \| \| \| \| \|_o_\|_o_\|/__\|_o_____\|_o_\|_o_\|_o_____\|/ ------------------------------------- - - - - - - - - - - - - - ------------------------------------- ``` ## Rules: The buildings 1. A basic building block looks like this (1 W, 1H) ``` __ /__ /\| (base cube is borrowed from the one at this question: \| \| \| http://stackoverflow.com/questions/1609702/code-golf-playing-cubes) \|___\|/ ``` 1. Our view is (ahum) ~3D so neighbouring buildings may hide parts of others. Buildings are 'logically' rendered from left to right. 2. The first building is preceded by two spaces to it's left. 3. You render every building by applying the WIDTH and HEIGHT to the dimensions of the base cube (do have a look at the sample output provided!). For reference: number of characters from the left to the right 'wall' (for a building with W > 1): (W\5)-(W-1). 4. Buildings with Height > 0 have ONE door (which is depicted by the character `o` and is located at two characters from the 'left' wall on the 'bottom' row ). The road:* 1. The road consists of three parts which we'll call 'top', 'middle' and 'bottom'. 2. The 'top' part and 'bottom' part are identical apart from the fact that the 'top' part is preceded by two spaces. 3. The middle part is preceded by one space and consists of a repetition of the following pattern: ``` '- ' ``` 4. Length is to be determined by the total width of the combined buildings: the most rightmost part of the road corresponds with the position of the 'right' wall of the 'last' building. ## Winners: This is code-golf! The winner is the qualifying contestant with the shortest solution (by source code count). The source must consist solely of printable ASCII characters. Have fun! Imaginary bonus points for (random) windows, cars or pedestrians. Feel free to comment if the specifications are not clear! [Answer] ## Haskell, 396 characters ``` w&h=take h((3," /\|"++(w-3)#'_'++"o_\|"):c[(3,"\| \|"++(w-1)#s++"\|")])++[(2,"\|/ "++(w-2)#'_'++"/"),(0," "++(w-2)#'_')]++c[(0,w#s)] p(w,h)=r.z take[sum w+k\|k<-[1..]]$([c"-",s:c"- "," "++c"-"]++).map r.foldl(z(%))((2+maximum h)#(5#s))$z(&)w h main=interact$unlines.p.q.map read.words;y%(d,x)=x++drop d y;q(x:y:z)=(4x:a,2y:b)where(a,b)=q z q x=(x,x);(#)=replicate;c=cycle;r=reverse;z=zipWith;s=' ' ``` Example output: ``` $ runghc Streetview.hs <<< "1 1 1 3 1 2 1 0 2 4 2 2 1 3 3 1" ______ /______ /\| __ \| \| \| __ /__ /\| \| \| \| /__ /\| \| \| \|__ \| \| \|_____\| \| \| \| \|/__ /\| \| \|/______\| \| \| _\| \| \| \| \| \| \| \| \|__________ /__\| \| \| \| \| \| \| \|/__________ /\| \| \| \| \| \|_\| \| \| \| \| \| \|_o_\|_o_\|_o_\|/__\|_o_____\|_o_____\|_o_\|_o_________\|/ ------------------------------------------------- - - - - - - - - - - - - - - - - - ------------------------------------------------- ``` [Answer] ## Python, 415 chars ``` I=eval(raw_input().replace(' ',',')) X=I[::2] Y=I[1::2] W=4sum(X)+6 H=2max(Y)+2 A=WH[' '] p=WH-W+2 for w,h in zip(X,Y):i=2h;j=4w;q=p-iW;r=p+j;s=q+j;A[p+1:q+1:-W]=A[p+2:q+2:-W]=i' ';A[p:q:-W]=A[r:s:-W]=A[r+2-W:s+2-W:-W]=i'\|';A[p+1:r]='_'(j-1);A[q+2:s]=A[q+3-W:s+1-W]='_'(j-2);A[q+1]=A[s+1]=A[r+1]='/';A[p+2]='_o'[h>0]; p+=j A[W-1::W]='\n'H D=(W-5)'-' print''.join(A)+' '+D+'\n'+(' - '*W)[:W-4]+'\n'+D ``` Uses slices to draw all the parts of the building. ``` $ echo "1 2 1 1 1 0 2 4 1 3 1 5 2 1" \| ./streetview.py __ /__ /\| ______ \| \| \| /______ /\| \| \| \| \| \| \|_\| \| \| \| \|/__\| \| \| __ \| \| \| \| \| /__ /\| \| \| \| \| \| \| \| \|__ \| \| \| \| \|______ \| \|/__ /\| \| \| \| \|/______ /\| \| \| \| \|_\| \| \| \| \| \| \|_o_\|_o_\|/__\|_o_____\|_o_\|_o_\|_o_____\|/ ------------------------------------- - - - - - - - - - - - - - ------------------------------------- ``` ]
[Question] [ In this challenge you will be creating an image preview compression algorithm. It's goal is to reduce an arbitrary image file to a 4 KiB preview image, that can be used to quickly identify images with very little bandwidth. You must write two programs (or one combined program): a compressor and a decompressor. Both must take a file or stdin as input, and output to a file or stdout. The compressor must accept one image in a mainstream lossless image format of choice (e.g. PNG, BMP, PPM), and output a file of at most 4096 bytes. The decompressor must accept any file generated by the compressor, and output an image as close as possible to the input. Note that there is no source code size limit for the encoder/decoder, so you can be creative in your algorithm. Restrictions: * No 'cheating'. Your programs may not use hidden inputs, storing data on the internet, etc. You are also forbidden from including features / data pertaining only to the set of scoring images. * For libraries / tools / built-ins you are allowed to use generic image processing operations (scaling, blurring, color space transformation, etc), but not image decoding / encoding / compression operations (except for compressor input and decompressor output). Generic compression / decompression is also disallowed. It is intended that you implement your own compression for this challenge. * The dimensions of the image output by the decompressor must exactly match those of the original file given to the compressor. You may assume that the image dimensions do not exceed 216 in either direction. * Your compressor must run on an average consumer PC in under 5 minutes, and the decompressor must run in under 10 seconds for any image in the set below. ## Scoring To help quick verification and visual comparison, please include a lossless image album of the test corpus after compression using your answer. Your compressor will be tested using the following [corpus of images](https://i.stack.imgur.com/R4aH4.jpg): [![starry](https://i.stack.imgur.com/RvZXy.jpg)](https://i.stack.imgur.com/rXufr.png) [![source](https://i.stack.imgur.com/uyWVg.jpg)](https://i.stack.imgur.com/Og99x.png) [![room](https://i.stack.imgur.com/4pTJP.jpg)](https://i.stack.imgur.com/huzmR.png) [![rainbow](https://i.stack.imgur.com/LpSVR.jpg)](https://i.stack.imgur.com/Omiyo.png) [![margin](https://i.stack.imgur.com/SY3bg.jpg)](https://i.stack.imgur.com/IzgAq.png) [![llama](https://i.stack.imgur.com/rpqHk.jpg)](https://i.stack.imgur.com/def6s.jpg) [![kid](https://i.stack.imgur.com/fw2H4.jpg)](https://i.stack.imgur.com/ioAss.png) [![julia](https://i.stack.imgur.com/qfDhT.jpg)](https://i.stack.imgur.com/BJWgm.png) You can download all images in a zip file [here](https://i.stack.imgur.com/R4aH4.jpg/zip). Your score will be the average [structural similarity index](https://en.wikipedia.org/wiki/Structural_similarity) for your compressor on all the images. We will be using the open source [`dssim`](https://github.com/pornel/dssim) for this challenge. It is easily built from source, or if you're on Ubuntu it also has a PPA. It is preferred if you score your own answer, but if you do not know how to build C applications and you do not run Debian/Ubuntu, you can let someone else score for you. `dssim` expects input/output in PNG, so convert your output to PNG first if you output in a different format. To make scoring painless, here's a quick helper Python script, usage `python score.py corpus_dir compressed_dir`: ``` import glob, sys, os, subprocess scores = [] for img in sorted(os.listdir(sys.argv[1])): ref, preview = (os.path.join(sys.argv[i], img) for i in (1, 2)) sys.stdout.write("Comparing {} to {}... ".format(ref, preview)) out = subprocess.check_output(["dssim", ref, preview]).decode("utf-8").split()[0] print(out) scores.append(float(out)) print("Average score: {:.6f}".format(sum(scores) / len(scores))) ``` --- Lowest score wins. [Answer] ## Python with PIL, score 0.094218 Compressor: ``` #!/usr/bin/env python from __future__ import division import sys, traceback, os from PIL import Image from fractions import Fraction import time, io def image_bytes(img, scale): w,h = [int(dimscale) for dim in img.size] bio = io.BytesIO() img.resize((w,h), Image.LANCZOS).save(bio, format='PPM') return len(bio.getvalue()) def compress(img): w,h = img.size w1,w2 = w // 256, w % 256 h1,h2 = h // 256, h % 256 n = wh total_size = 41024 - 8 #4 KiB minus 8 bytes for # original and new sizes #beginning guess for the optimal scaling scale = Fraction(total_size, image_bytes(img, 1)) #now we do a binary search for the optimal dimensions, # with the restriction that we maintain the scale factor low,high = Fraction(0),Fraction(1) best = None start_time = time.time() iter_count = 0 while iter_count < 100: #scientifically chosen, not arbitrary at all #make sure we don't take longer than 5 minutes for the whole program #10 seconds is more than reasonable for the loading/saving if time.time() - start_time >= 560-10: break size = image_bytes(img, scale) if size > total_size: high = scale elif size < total_size: low = scale if best is None or total_size-size < best[1]: best = (scale, total_size-size) else: break scale = (low+high)/2 iter_count += 1 w_new, h_new = [int(dimbest[0]) for dim in (w,h)] wn1,wn2 = w_new // 256, w_new % 256 hn1, hn2 = h_new // 256, h_new % 256 i_new = img.resize((w_new, h_new), Image.LANCZOS) bio = io.BytesIO() i_new.save(bio, format='PPM') return ''.join(map(chr, (w1,w2,h1,h2,wn1,wn2,hn1,hn2))) + bio.getvalue() if __name__ == '__main__': for f in sorted(os.listdir(sys.argv[1])): try: print("Compressing {}".format(f)) with Image.open(os.path.join(sys.argv[1],f)) as img: with open(os.path.join(sys.argv[2], f), 'wb') as out: out.write(compress(img.convert(mode='RGB'))) except: print("Exception with {}".format(f)) traceback.print_exc() continue ``` Decompressor: ``` #!/usr/bin/env python from __future__ import division import sys, traceback, os from PIL import Image from fractions import Fraction import io def process_rect(rect): return rect def decompress(compressed): w1,w2,h1,h2,wn1,wn2,hn1,hn2 = map(ord, compressed[:8]) w,h = (w1256+w2, h1256+h2) wc, hc = (wn1256+wn2, hn1256+hn2) img_bytes = compressed[8:] bio = io.BytesIO(img_bytes) img = Image.open(bio) return img.resize((w,h), Image.LANCZOS) if __name__ == '__main__': for f in sorted(os.listdir(sys.argv[1])): try: print("Decompressing {}".format(f)) with open(os.path.join(sys.argv[1],f), 'rb') as img: decompress(img.read()).save(os.path.join(sys.argv[2],f)) except: print("Exception with {}".format(f)) traceback.print_exc() continue ``` Both scripts take input via command line arguments, as two directories (input and output), and convert all images in the input directory. The idea is to find a size that fits under 4 KiB and has the same aspect ratio as the original, and use a Lanczos filter to get as high of a quality out of the downsampled image as possible. [Imgur album of compressed images, after resizing to original dimensions](https://i.stack.imgur.com/a5bYG.jpg) Scoring script output: ``` Comparing corpus/1 - starry.png to test/1 - starry.png... 0.159444 Comparing corpus/2 - source.png to test/2 - source.png... 0.103666 Comparing corpus/3 - room.png to test/3 - room.png... 0.065547 Comparing corpus/4 - rainbow.png to test/4 - rainbow.png... 0.001020 Comparing corpus/5 - margin.png to test/5 - margin.png... 0.282746 Comparing corpus/6 - llama.png to test/6 - llama.png... 0.057997 Comparing corpus/7 - kid.png to test/7 - kid.png... 0.061476 Comparing corpus/8 - julia.png to test/8 - julia.png... 0.021848 Average score: 0.094218 ``` [Answer] ## Java (vanilla, should work with java 1.5+), score 0.672 It does not generate particularly good dssim scores but, to my eye it produces more human friendly images... [![starry](https://i.stack.imgur.com/xZjcc.jpg)](https://i.stack.imgur.com/fJuV1.png) [![source](https://i.stack.imgur.com/zTlmh.jpg)](https://i.stack.imgur.com/ulbXH.png) [![room](https://i.stack.imgur.com/Byhav.jpg)](https://i.stack.imgur.com/9pLuV.png) [![rainbow](https://i.stack.imgur.com/hRGwj.jpg)](https://i.stack.imgur.com/UnvCu.png) [![margin](https://i.stack.imgur.com/jd6VI.jpg)](https://i.stack.imgur.com/96bBn.png) [![llama](https://i.stack.imgur.com/xAyIa.jpg)](https://i.stack.imgur.com/PP0xF.png) [![kid](https://i.stack.imgur.com/oNGVH.jpg)](https://i.stack.imgur.com/xKruU.png) [![julia](https://i.stack.imgur.com/jkMOm.jpg)](https://i.stack.imgur.com/06chF.png) Album: <https://i.stack.imgur.com/ZU3hc.jpg> Scoring script output: ``` Comparing corpus/1 - starry.png to test/1 - starry.png... 2.3521 Comparing corpus/2 - source.png to test/2 - source.png... 1.738 Comparing corpus/3 - room.png to test/3 - room.png... 0.1829 Comparing corpus/4 - rainbow.png to test/4 - rainbow.png... 0.0633 Comparing corpus/5 - margin.png to test/5 - margin.png... 0.4224 Comparing corpus/6 - llama.png to test/6 - llama.png... 0.204 Comparing corpus/7 - kid.png to test/7 - kid.png... 0.36335 Comparing corpus/8 - julia.png to test/8 - julia.png... 0.05 Average score: 0.672 ``` The compression chain: ``` 1. if filter data has already been generated goto step 6 2. create sample images from random shapes and colours 3. take sample patches from these sample images 4. perform k-clustering of patches based on similarity of luminosity and chomanosity. 5. generate similarity ordered lists for each patch as compared to the other patches. 6. read in image 7. reduce image size to current multiplier blocksize 8. iterate over image comparing each blocksize block against the list of clustered luminosity patches and chromanosity patches, selecting the closest match 9. output the index of the closet match from the similarity ordered list (of the previous block) (repeat 8 for chromanosity) 10. perform entropy encoding using deflate. 11. if output size is < 4096 bytes then increment current multiplier and repeat step 7 12. write previous output to disk. ``` To decompress, inflate and then read the block indexes and output the corresponding patch to the output file, then resize to the original dimensions. Unfortunately the code is too large for stackoverflow so can be found at <https://gist.github.com/anonymous/989ab8a1bb6ec14f6ea9> To run: ``` Usage: For single image compression: java CompressAnImageToA4kibPreview -c <INPUT IMAGE> [<COMPRESSED IMAGE>] For multiple image compression: java CompressAnImageToA4kibPreview -c <INPUT IMAGES DIR> [<COMPRESSED IMAGE DIR>] For single image decompression: java CompressAnImageToA4kibPreview -d <COMPRESSED IMAGE> [<DECOMPRESSED IMAGE> For multiple image decompression: java CompressAnImageToA4kibPreview -d <COMPRESSED IMAGE DIR> [<DECOMPRESSED IMAGES DIR>] If optional parameters are not set then defaults will be used: For single image compression, compressed image will be created in same directory are input image and have '.compressed' file extension. For multiple image compression, compressed images will be created in a new 'out' sub directory of <INPUT IMAGES DIR> and have '.compressed' file extensions. For single image decompression, decompressed image will be created in same directory are input image and have '.out.png' file extension. For multiple image decompression, decompressed images will be created a new 'out' sub directory of <COMPRESSED IMAGE DIR> and have '.png' file extensions. ``` The first time this application is run, required files will be generated and saved in a directory relative to execution working dir. This may take a few minutes. For subsequent executions, this step will not need to be performed. ]
[Question] [ So, now that it's 2015, and [a bunch of answers](https://codegolf.stackexchange.com/a/17010/7110) [from last year's puzzle](https://codegolf.stackexchange.com/a/17021/7110) [are now starting to](https://codegolf.stackexchange.com/a/17046/7110) [produce invalid output](https://codegolf.stackexchange.com/a/17008/7110), it's time for a question involving the number 2015. Except... why? Wouldn't you like it if your date-based answers to last year's problem were to stay valid? Why don't we change our calendar so that it's never 2015, and we simply continue living in 2014, forever and ever? Let's define a new date notation, called Eternal 2014 notation, as follows: > > * For dates 2014 and before, the dates will be the same as in the [proleptic Gregorian calendar](http://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar). > * For dates in years 2015 and onward, the year will stay 2014, and the month will be the number it would be if the same month cycle in 2014 were to continue forever past month 12. So `2015-02-08` would be `2014-14-08`, and `2020-12-31` would be `2014-85-02`. Note that leap days are not accounted for because 2014 is not a leap year. > > > Your task is to build a program or function that will take a [Julian astronomical date](http://en.wikipedia.org/wiki/Julian_day) as input and return a string with the date corresponding to that Julian date in Eternal 2014 notation, in either `YYYY-MM-DD` or `DD/MM/YYYY` format. You may assume that the Julian day entered will always be an integer from `1721426` (January 1, 1) to `2914695` (January 23, 3268) inclusive. Years may contain leading zeros to pad to 4 digits or not, but months and days must always have leading zeros to pad to two digits (and years may not contain leading zeros to pad to any number of digits other than 4). Here are some example inputs and their outputs, in all acceptable formats: ``` > 1721426 1-01-01 01/01/1 0001-01-01 01/01/0001 > 2086302 999-12-31 31/12/999 0999-12-31 31/12/0999 > 2456659 2014-01-01 01/01/2014 > 2456789 2014-05-11 11/05/2014 > 2457024 2014-13-01 01/13/2014 > 2457389 2014-25-01 01/25/2014 > 2469134 2014-411-07 07/411/2014 > 2567890 2014-3657-29 29/3657/2014 > 2914695 2014-15059-23 23/15059/2014 ``` You may not use any built-in date processing libraries in your language. All calculations must be done algorithmically within the program's source code itself. The shortest program (in bytes) to achieve this in any language wins. [Answer] ## Python 2, 166 bytes ``` n=input() d=m=y=1 M=([3]+[3,2]3)2 while n>1721426: n-=1;d+=1;M[2]=y%400<1or y%4<1<y%100 if d>M[m%12]+28:m+=1;d=1 if m>12<2014>y:y+=1;m=1 print'%02d/'2%(d,m)+`y` ``` This cycles through every day from January 1, 1 (1721426) to the given date, incrementing the current day, month and year as it goes. The last test case takes about a second on my computer. Output is printed in the second format: ``` 01/01/1 31/12/999 23/15059/2014 ``` [Answer] # [Ostrich 0.5.0](https://github.com/KeyboardFire/ostrich-lang/releases/tag/v0.5.0-alpha), 197 bytes ``` G~:J1401+4J274227+146097/F34/F+38~+:f43+:e1461:p%4/F:g52+:h153:s%5/F1+:D;hs/F2+12:n%1+:M;ep/F4716-n2+M-n/F+:Y;{2014:Y;D365+:D;{M1-12%[31:x28x 30:yxyxxyxyx]=:dD<.{Dd-:D;M1+:M;}}(}Y2014-D"/M"/Y ``` Ungolfed (ha): ``` G~:J; 4716:y;1401:j;2:m;12:n;4:r;1461:p;3:v;5:u;153:s;2:w;274277:B;38~:C; Jj+4JB+146097/F34/F+C+:f; rfv+:e; ep%r/F:g; ugw+:h; hs%u/F1+:D; hs/Fm+n%1+:M; ep/Fy-nm+M-n/F+:Y; { 2014:Y; D365+:D; { M1-12%[31 28 31 30 31 30 31 31 30 31 30 31]=:d D<.{Dd-:D;M1+:M;} }( }Y2014-* D"/M"/Y ``` I'm... really just exhausted from all the New Year's happiness and what not. That's why I haven't golfed this very much. I may or may not come back to make it better later. Algorithm from <https://en.wikipedia.org/wiki/Julian_day#Gregorian_calendar_from_Julian_day_number> [Answer] ## PHP (278) Run on command line using `php -R '<code>'`. (The flag counts as one character.) ``` if(0<$N=($n=$argn-1721426)-735233){$n=$N%365+735233;$o=12($N/365\|0);}for($y=1+400($n/146097\|0)+100(($n%=146097)/36524\|0)+(($n%=36524)/1461<<2)+(($n%=1461)/365\|0);($n%=365)>=$d=@++$m-2?30+($m+($m>>3)&1):29-($y%4\|\|!($y%100)&&$y%400);)$n-=$d;printf("$y-%02d-%02d",$m+@$o,$n+1); ``` More readable version (run using filename and without `-R`): ``` <?php // step 1: read the input and fix up 2014 dates if (0 < $N = ($n = fgets(STDIN) - 1721426) - 735233) { $n = $N % 365 + 735233; // wrap around to 2014-01-01 $o = 12 ($N / 365 \| 0); // compute month offset } for ( // step 2: extract year $y = 1 + 400 * ($n / 146097 \| 0) + 100 * (($n %= 146097) / 36524 \| 0) + (($n %= 36524) / 1461 << 2) + (($n %= 1461) / 365 \| 0); // step 3: extract month and day ($n %= 365) >= $d = @++$m - 2 ? 30 + ($m + ($m >> 3) & 1) : 29 - ($y % 4 \|\| !($y % 100) && $y % 400); ) $n -= $d; // step 4: print date string, adding the month offset // previously computed in step 1. printf("$y-%02d-%02d", $m + @$o, $n + 1); ``` [Answer] # C 176 Thanks to @ceilingcat for some very nice pieces of golfing - now even shorter ``` y=1;m;d;main(n,a)int**a;{for(n=atoi(a[1]);n-->1721426;)++d>(~m%2+m%12/7?30:m%12-1?29:y%(y%100?4:400)?27:28)&&(d=!++m,m>11&y<2014)&&(m=!++y);printf("%d-%02d-%02d\n",y,m+1,d+1);} ``` It uses the same algorithm as the Python 2 answer by @grc [Try it online!](https://tio.run/##JY1LDsIgFADPYhMaKBB5T@wP2x5EXZCSmi6gpumGGL062riZTGYzo3yMY0qxA@ONM97OgQZh2Ry2orDmNS0rDZ3dlpnaK9yZCVL2UCFoLA3j3PX04wlyTwCP1XBS7W4SBmzaSGgkoNSgW60UG7BqsWZ5Tl134NwL3wPk8YIK9F79XiMzz/U3n2hGnCQK/7iFTEThOQjHgZl3SgnPZVU36gs "C (gcc) – Try It Online") ]
[Question] [ [Magic: the Gathering](https://en.wikipedia.org/wiki/Magic:_The_Gathering) is a trading card game where, among other things, players play cards representing creatures, which can then attack the other player, or defend against the other player's attacks by blocking. In this code-golf challenge, your program will be in the place of a Magic player deciding how to block in combat. --- Each creature has two relevant attributes: Power, and toughness. A creature's power is the amount of damage it can deal in a combat, and its toughness is the amount of damage necessary to destroy it. Power is always at least 0, and toughness is always at least 1. During combat in Magic, the player whose turn it is declares some of their creatures to be attacking the opponent. Then, the other player, known as the defending player, may assign their creatures as blockers. A creature may block only one creature per combat, but multiple creatures may all block the same creature. After blockers are declared, the attacking player decides, for each attacking creature that was blocked, how to distribute the damage (equal to its power) that that creature deals to the creatures blocking it. Then, damage is dealt. Each creature deals damage equal to its power. Attacking creatures that were blocked deal damage as descibed above. Unblocked attacking creatures deal damage to the defending player. Blocking creatures deal damage to the creature they blocked. Creatures belonging to the defending player that did not block deal no damage. (Creatures are not required to block.) Finally, any creature dealt damage equal to or greater than its toughness is destroyed, and removed from the battlefield. Any amount of damage less than a creature's toughness has no effect. --- Here's an example of this process: A creature with power P and toughness T is represented as `P/T` ``` Attacking: 2/2, 3/3 Defending player's creatures: 1/4, 1/1, 0/1 Defending player declares blockers: 1/4 and 1/1 block 2/2, 0/1 does not block. Attacking player distributes damage: 2/2 deals 1 damage to 1/4 and 1 damage to 1/1 Damage is dealt: 2/2 takes 2 damage, destroyed. 3/3 takes 0 damage. 1/1 takes 1 damage, destroyed. 1/4 takes 1 damage. 0/1 takes 0 damage. Defending player is dealt 3 damage. ``` --- The defending player has 3 goals in combat: Destroy the opponent's creatures, preserve one's own creatures, and be dealt as little damage as possible. In addition, creatures with more power and toughness are more valuable. To combine these into a single measure, we will say that the defending player's score from a combat is equal to the sum of the powers and toughnesses of their surviving creatures, minus the sum of the powers and toughnesses of their opponent's surviving creatures, minus one half of the amount of damage dealt to the defending player. The defending player wants to maximize this score, while the attacking player wants to minimize it. In the combat shown above, the score was: ``` Defending player's surviving creatures: 1/4, 0/1 1 + 4 + 0 + 1 = 6 Attacking player's surviving creature: 3/3 3 + 3 = 6 Damage dealt to defending player: 3 6 - 6 - 3/2 = -1.5 ``` If the defending player had not blocked at all in the combat described above, the score would have been ``` 8 - 10 - (5/2) = -4.5 ``` The optimal choice for the defending player would have been to block the `2/2` with the `1/1` and the `1/4`, and to block the `3/3` with the `0/1`. If they had done so, only `1/4` and the `3/3` would have survived, and no damage would have been dealt to the defending player, making the score ``` 5 - 6 - (0/2) = -1 ``` --- Your challenge is to write a program which will output the optimal blocking choice for the defending player. "Optimal" means the choice which maximizes the score, given that the opponent distributes damage in the way which minimizes the score, given how you blocked. This is a maximin: The maximum score over the damage distributions which minimize score for each blocking combination. --- Input: The input will consist of two lists of 2-tuples, where each 2-tuple is of the form (Power, Toughness). The first list will contain the powers and toughnesses of each attacking creature (you opponent's creatures). The second list will contain the powers and toughnesses of each of your creatures. Tuples and lists may be represented in any convenient format, such as: ``` [[2, 2], [3, 3]] [[1, 4], [1, 1], [0, 1]] ``` Output: The output will consist of a series of 2-tuples, in the form (blocking creature, blocked creature) - that is, one of your creatures followed by one of their creatures. Creatures will be refered to by their index in the input lists. Indexes may be 0 or 1 indexed. Again, any convenient format. Any order is fine. For example, the optimal blocking scenario from above, given the above input, might be represented as: ``` [0, 0] # 1/4 blocks 2/2 [1, 0] # 1/1 blocks 2/2 [2, 1] # 0/1 blocks 3/3 ``` Examples: ``` Input: [[2, 2], [3, 3]] [[1, 4], [1, 1], [0, 1]] Output: [0, 0] [1, 0] [2, 1] Input: [[3, 3], [3, 3]] [[2, 3], [2, 2], [2, 2]] Output: [1, 0] [2, 0] or [1, 1] [2, 1] Input: [[3, 1], [7, 2]] [[0, 4], [1, 1]] Output: [1, 0] or [0, 0] [1, 0] Input: [[2, 2]] [[1, 1]] Output: (No output tuples). ``` Input and output may be via STDIN, STDOUT, CLA, function input/return, etc. [Standard loopholes](https://codegolf.meta.stackexchange.com/q/1061/20080) apply. This is code-golf: shortest code in bytes wins. --- To clarify the spec and provide initial ideas, [this pastebin](http://pastebin.com/VNMfcYy0) provides a reference solution in Python. The `best_block` function is a sample solution to this challenge, and running the program will provide more verbose input and output. [Answer] # JavaScript (ES7), ~~354~~ 348 bytes Takes input as `([attackers], [defenders])`. ``` (a,d,O,M)=>eval(`for(N=(A=a.push([,0]))d.length;N--;)O=a[X='map'](([P,T],i)=>S-=((g=(n,l)=>n?l[X](([t,S],i)=>g(n-1,b=[...l],b[i]=[t-1,S])):m=l[X](([t,S])=>s+=t>0&&S,s=0)&&s>m?m:s)(P,l[n=0,i][X](m=([p,t])=>[t,p+t,n+=p])),n<T&&P+T)+(l[i]<1?T/2:-m),S=0,d[X]((x,i)=>l[(j=N/Ai%A\|0)<A-1&&o.push([i,j]),j].push(x),o=[],l=a[X](_=>[])))&&S<M?O:(M=S,o)`) ``` [Try it online!](https://tio.run/##dZDdboJAEIXv@xTcFGdlQMAmTdSR8AD@JHBhstlU/McsCxFqetF3t7uojW3ai83M7JzvnM0es3NWr0951biq3GwvO7pAhhuc4YTReHvOJCx35QmmBDFlXvVeH4CjLxjrdjee3Kp9cxhOXXfIZpTxBXWKrOoIAD7HVGCuPRKXAPYECqWeVCT5wuwbTK77PSg3wBVxz/OkwBXPBfFGXyU6ZFDQg16ra4easW/bCdbkM9uux0VUDGoGc5RckY@5MPqCgFfYGEKTldOgcqjShqhGqW3PnZQ5IHXUKIjSXjhwC4aJpjdt2Ef7MMnhSNNe3O3mz/Gnz0axG9h2efuDHI@C6XMdPxiWxAVK8wkC3nSsDtPvS0aTaDaACSVYsiW7rEtVl3LryXIPO@A8RCsUaPE@Wn1hGh6g9WIaXQNTfVO12dNvtEV@oOHt5m7a1n/Q1vu1FRjUf0z9Cwm/pXfJ5Qs "JavaScript (Node.js) – Try It Online") ## Less golfed and formatted This code is identical to the golfed version, just without the `map` aliases and the `eval()` wrapping for readability. ``` (a, d, O, M) => { for(N = (A = a.push([, 0])) d.length; N--;) O = a.map(([P, T], i) => S -= ( (g = (n, l) => n ? l.map(([t, S], i) => g(n - 1, b = [...l], b[i] = [t - 1, S])) : m = l.map(([t, S]) => s += t > 0 && S, s = 0) && s > m ? m : s )( P, l[n = 0, i].map(m = ([p, t]) => [t, p + t, n += p]) ), n < T && P + T ) + ( l[i] < 1 ? T / 2 : -m ), S = 0, d.map((x, i) => l[ (j = N / A i % A \| 0) < A - 1 && o.push([i, j]), j ].push(x), o = [], l = a.map(_ => []) ) ) && S < M ? O : (M = S, o) return O } ``` ## How? ### Initialization and main loop The first thing we do is add a dummy attacking creature with an undefined power and a toughness of \$0\$. The `push` method returns the new number \$A\$ of attacking creatures, including this one. ``` A = a.push([, 0]) ``` We are going to block this dummy creature instead of blocking no creature at all. This allows some simplifications in the code. The number of combinations for the defending player can be expressed as \$A^D\$, where \$D\$ is the number of defenders. We use a for loop with the counter \$N\$ to iterate over all these possibilities. ``` for(N = (A = a.push([, 0])) d.length; N--;) ``` The score of the current iteration and the maximum score are stored in \$S\$ and \$M\$ respectively. Similarly, the current solution and the best solution are stored in \$o\$ and \$O\$. At the end of each iteration, we test whether \$M\$ and \$O\$ need to be updated. ``` O = (...) && S < M ? O : (M = S, o) ``` ### Building our defense Below is the block of code which is executed at the beginning of each iteration. A new important variable in there is \$l\$, which holds a list of blockers for each attacker. ``` d.map((x, i) => // for each defender x at position i: l[ // update l[]: (j = N / A i % A \| 0) // j = index of the attacker that we're going to block < A - 1 && // if this is not the 'dummy' creature: o.push([i, j]), // add the pair [i, j] to the current solution j // use j as the actual index to update l[] ].push(x), // push x in the list of blockers for this attacker o = [], // initialize o to an empty list l = a.map(_ => []) // initialize l to an array containing as many empty lists // that there are attackers ) // end of map() ``` ### Optimizing the attack The decisions of the attackers are uncorrelated to each other. The global optimum for the attacking side is the sum of the local optima for each attacker. We iterate on each attacker of power \$P\$ and toughness \$T\$ at index \$i\$. ``` a.map(([P, T], i) => ...) ``` To find the best decision for an attacker, we first build a new list derived from \$l[i]\$: ``` l[n = 0, i].map(m = ([p, t]) => [t, p + t, n += p]) ``` Each entry in this list contains the toughness of the blocker, followed by its score (power + toughness). While building this list, we also compute \$n\$ which is the sum of the powers of all blockers. We'll use it later to test if the attacker is destroyed. (The fact that intermediate sums are stored as a 3rd entry for each blocker is just a golfing trick to save a few bytes. This 3rd entry is not used.) We now call the recursive function \$g\$ with 2 parameters: the power \$P\$ of the current attacker and the list defined above. This function tries all possible ways of dispatching the damage points among the blockers. ``` (g = (n, l) => // n = remaining damage points; l = list of blockers n ? // if we still have damage points: l.map(([t, S], i) => // for each blocker of toughness t and score S at index i: g( // do a recursive call: n - 1, // decrement the number of damage points b = [...l], // create a new instance b of l b[i] = [t - 1, S] // decrement the toughness of blocker i ) // end of recursive call ) // end of map() : // else: m = // update the best score m (the lower, the better): l.map(([t, S]) => // for each blocker of toughness t and score S: s += t > 0 && S, // add S to s if this blocker has survived s = 0 // start with s = 0 ) && // end of map() s > m ? m : s // set m = min(m, s) ) // ``` ### Updating the defender score After each iteration on an attacker, we update the defender score with: ``` S -= (n < T && P + T) + (l[i] < 1 ? T / 2 : -m) ``` The left part subtracts the score of the attacker if it has survived. The right part subtracts half the toughness of the attacker if the attack was not blocked at all, or adds the best attacker score otherwise (which is the worst one from the defending side perspective). ]
[Question] [ Cubes can be made of six squares as sides. But you could also fold three 2x1 rectangles in half and glue them together to form a cube. Now in this challenge you get a set of pieces which are each made from squares, and you have to determine whether you can choose pieces to form a unit cube. Not all of the pieces have to be used, there might be some left over. ## Details The pieces are given as a string of two different characters or a black and white image or any convenient 2D raster format. In the following I assume the pixels that form the pieces are black, and the background is in white. Two pixels who share a side are considered to belong to the same piece. The pieces can only be folded along the gridlines that separate the pixels, and they cannot be cut. Each side of the cube has the size of one pixel, and each side of the cube can only be made of a single layer. The output must be a truthy or falsey value. ## Testcases In the following, the spaces are background and hash symbols `#` represent the pieces. (more to be added) ### Valid ``` ## ## ## ``` --- ``` # #### # ``` --- ``` # # # # # # # ``` --- ``` # ## ## # ``` ### Invalid ``` ### ### ``` --- ``` # # #### ``` --- ``` ### ## #### ``` Run the following snippet for more testcases. ``` document.getElementById("asdfasdf").style.display = "block"; ``` ``` <div id="asdfasdf" display="none"> <h3>Valid</h3> <pre><code> ## ## ## </code></pre> <hr> <pre><code> # #### # </code></pre> <hr> <pre><code> # # # # # # # </code></pre> <hr> <pre><code> # ## ## # </code></pre> <hr> <pre><code> # # ### # </code></pre> <h3>Invalid</h3> <pre><code> ### ### </code></pre> <hr> <pre><code> # # #### </code></pre> <hr> <pre><code> ### ## #### </code></pre> <hr> <pre><code> ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## </code></pre> </div> ``` PS: This is a generalization of [this challenge](https://codegolf.stackexchange.com/questions/49663/can-you-fold-a-hexomino-into-a-cube) [Answer] # C, ~~824~~ 803 bytes ``` #define Z return #define Y charb #define N --n i,j,n,w,h,A,B,C,D,E,F,G,H;char c[9999],r,d;x(b)Y;{if(b<c\|\|b<35)Z;++n;b^=1;x(b-1);x(b+1);x(b-w);x(b+w);}m(b,p,y)Y,p;{d=b;if(!y)for(y=-1,--p;1[++p]&31;)d+=w;for(i=0;p&31?!(p&16>>i)\|\|b[i]&1:0;++i>4?p+=y,b+=w,i=0:0);Z!(p&31)?x(d),n:0;}a(b)Y;{for(j=n=0;j<wh;++j)if(m(c+j,b,1)\|\|m(c+j,b,0))Z n;Z 0;}f(Y){bzero(c,9999);for(h=0,b=strcpy(c,b);r=b,b=strchr(b+1,10);h++,w=b-r);for(A=2,r=1+"@_`^C@\|T@^R@XO@XX`\|FB@\|PP@\|DD@PXN@XHX@XPX`PPXL@XHHX@XLDD@XPPX`PPPXH@PXHHH@PPPPP@";r;r+=A+=r[-1]/96)while(a(r));A=B=C=D=E=F=G=H=0;while(a("PX")\|\|a("XH")) (n-=3)?N?N?N?0:++H:++G:++F:++C;while(a("^")\|\|a("PPPP"))(n-=4)?N?N?0:++H:++G:++E;while(a("P"))N?N?N?N?N?N?0:++H:++G:++F:++D:++B:++A;Z H\|\|(G&&A)\|\|(F&&B+B+A>1)\|\|(E&&A>1)\|\|D>1\|\|C>1\|\|((D\|\|C)3+B2+A>5)(A>1\|\|B>2\|\|AB);} ``` > > Note: Includes a bug fix (the previous entry falsely identified a tromino and two dominoes as forming a cube).* > In the TIO driver code, there are more test cases and there's now a pass/fail tracker; hexomino test cases were updated with the expected pass/fail value in the label. > > > [Try it online!](https://tio.run/nexus/c-gcc#1VptV9pKEP7Or5gmp5IloRICWIlBwDfuOT2W0/YDavU2CaHEYohJKFLxt/fOBlBAwsUVFOPJy@7OPDPzzOxAPPzl61bDdiw4Bc8KOp4TG02cgNnUvYRxP3EMyaQTs6VLyZG6UlMqSWVpT9qXDqRD6UiqqFQczLNtPM6lhCcl6uqNYJAT9dZuCMaO2e8njB0lS05VUXTUhHGhyVQgKRN6Ewe3ZHcwwtvdlWBIrtQjJ1LCVW/rmqEi0LseabQ9oaclZSmZdFX5TBTd8w1FVkld1LoqXbS1lJpwcW73nYB3OVco2KTfN87s8w05n0L7diGz64paTzJQR0L5fIqop6G0IpPdG6FOJAcl7/RBBBT1UnMQ93Knm2giwiVBZ64EU7yUDElG9NFzipBTcNRTQO2GcEJujT@W1xZMiRJDQv@aWkoyND/wTLeHCwZRPc0YzjQ9yoUkoz9NUZS6mpH0BlolLS15mixyxX9/XOwV@9@KF1@Ktc/FWu1H/7Bc7Ferxf7@frFaOy7WKrVirVr7Ua3WPuGAjj7hUq0azlVrFZSqVPBKjyKnJjzVE7WSqHlnSfl8cztHuk27ZQm64BGilrSytqftawfaoXakVZCE0SpXrXEYOj7UKhwhIDhJTSG7x@FfKi@KFTyP8DzEc@9B7WKoRc2jHlXLkEdKB2N2UOp49@FvGnsfzzKeJeS90u8LRxsbJTQhHG5slMWyWCrQDAkHOBs@7Rfkfn@PXgRhH59IQhHLiTTKZUlCKNGFciHd75cSZazDv5ub8K1pQaPjmIHddoBrcGD91lsdPbB80MG3nZ8tCzB9@ABdO2hC/LsTDzeQbgaWh0JOfbjBfAgQK/A6QbO32dBbfg8olPUhFhvZabda7S6FQvgAdev18GJT43oLzHYdAdrQtFou2K1WBw2jJ9Bt6gHYQdyHehu18yHgV1xzu23vF9Xwm@0u0JO68NOz6yh7pTu222khQD022MLXgz2sAqrvJGlYAwQU9i1XD20ZnUbD8kKFBPimZl6rAEMFC2NtNx70qBt7bee35diWY1pwZQXNdh3D9MZkhkhWIAyeDAK3EG5mB4PCmrN3qFd07xL00D7HKRhtoWsJ5dWBHyJOtixHoBMDxjEi9S5GYzcFRI2hoy5mKmgIHABHVDpBLYWG3WvEwIajmap7veObaNC9lvAy1MTDxwybTewVZDRj6r4FcYjnwe0EFEaIf4ijfcOz9F/qhBA/LsRHCHHjQp8jhLDC8uMTqYlRvDjA8AUOQ5wMeBIN27veaQUPFjGwKZG72Ohyj0gHQ3pTauwu1tDtlo85CfxAuMGmTZv@zTutR0QxXLpPxg3mInal244woI@mfGiG48Pju8MNJ8YcP5RlIUXy8L6OyxK10sC8E9puVRjmVp2J9wDH0UsUfHop8DxEwCvLgOchCj7DBg9T3keRk2WDn3Q@Cjz3fHA@Mq1bzwbnI2smLS/B86iKSaeXwDlEDydsKcvIL0QOJ2yxlCqMF/6MBEXZygryDFvyPFtTgcyldMJWjsEWD2y2tp5uaz6H0bYUeflxRdWGkl5@viJtKQwcTnfMRW2xteeJuCL7p8LWnGE6kij43PN5igZna8@T@Z4NnWFozpP98tFnTNRowmyaia5JthYypDw3PpgicrH4MkxbNJLWqU4R1ckzDEU@L75FzeaeXZ/AL2SIZSMsSuu4oay8XEORhZJNPzdj0419oYxlFaaPxmhDUf0lm2GJD6IzFklkdrmNLNpQbpUdJTpjW0wdMyIvXywfX2Z35EKK5W1rLmaaDRPmgipMoPA/qJmCzMAozI8/@3RX4VH7m@6788aPXcg9PS54VIbPc2HrySzAjIOHmbPTL@QL6gG8ot5jij6ukiJGl/n1omh7DSmC16R2RgtPPXmzry1H/Ko4kt9iHfGsHAETR@m3Ukf869WRwsoRv7JYZ3P7ihxlVrjXZnHET@yTpdbfyjjKrgdH07NrxVFuXTji15ejrRX27NXWEf9iHH18YY4mZZe611b2HXL7hfca8G@Oo3TqpeuIH5d@GxzJL84RPyCE5xm/Z7PqsXOUful3kQU44teMI2UpdQSLf67BOEfAWEfAyBHT@1o6w8wRz8QRvEGO2L9nL4ejCKrWiqPF/lk80nrvU8Hwt2q73GHpn09cnquWvn4d/tbNboAQLpLbsR/TIXz4czsf6JpVv4dAI3exu7//AQ "C (gcc) – TIO Nexus") ...and before explaining this in detail, it's worth a high level overview. Basic Overview This algorithm applies a pattern matcher to classify each polyomino it finds with a given pattern as its subset. As polyominoes are matched they are "unmarked", excluding them from pattern matching again. The initial classification given by the matcher is simply a count of the number of tiles in the polyomino. The matcher is applied first to cull out all polyominoes that cannot be folded onto a cube; the classification of these polyominos is discarded. The match succeeds if these polyominoes appear within higher level ones; therefore, we only care about the smallest subset of "unfoldable" for each class. Shown here along with padded encodings are all such polyominoes (excluding their vertical reflections). The encoding uses bits 4-0 of each character to represent squares on each row: ``` [^C```] [XHX``] [PPPXH] [XHHX`] [PXN``] [\|PP``] ####. ##... #.... ##... #.... ###.. ...## .#... #.... .#... ##... #.... ..... ##... #.... .#... .###. #.... ..... ..... ##... ##... ..... ..... ..... ..... .#... ..... ..... ..... [\|FB``] [XPX``] [PPXL`] [XLDD`] [XPPX`] [\|DD``] ###.. ##... #.... ##... ##... ###.. ..##. #.... #.... .##.. #.... ..#.. ...#. ##... ##... ..#.. #.... ..#.. ..... ..... .##.. ..#.. ##... ..... ..... ..... ..... ..... ..... ..... [\|T```] [^R```] [PXHHH] [XO```] [_````] [PPPPP] ###.. ####. #.... ##... ##### #.... #.#.. #..#. ##... .#### ..... #.... ..... ..... .#... ..... ..... #.... ..... ..... .#... ..... ..... #.... ..... ..... .#... ..... ..... #.... [XX```] ##... ##... ..... ..... ..... ``` Once these polyominoes are culled, we categorize the remaining polyominoes into relevant categories. It's worth noting that in almost all cases, one can just find polyominoes that remain (those foldable onto cubes) and simply search for sums of six. There are two exceptions: * A corner tromino and a line tromino cannot form a cube * A line tetromino and a domino cannot form a cube In order to be able to accommodate this restriction we form 8 categories, from A-H: A for monominoes (lone tiles), B for dominoes, C for corner trominoes, D for line trominoes, E for line tetrominoes, F for other tetrominoes, G for pentominoes, and H for hexominoes. Anything not falling into one of these categories is just ignored. Counting polyominoes that fall into each category suffices. At the end, we just return truthiness or falsiness based on a giant equation and these tabulations. Ungolfed with comments ``` i,j,n,w,h,A,B,C,D,E,F,G,H;char c[9999],r,d; x(b)charb;{ // recursively unmarks polyomino pointed to by b. if(b<c\|\|b<35)return; ++n; b^=1; // Tabulates tiles in n as it goes. x(b-1);x(b+1);x(b-w);x(b+w); // left/up/down/right } m(b,p,y)charb,p;{ // pattern match area b with pattern p, direction y. // y=1 scans down; y=0 scans up. d=b; // d tracks a tile in the currently matched pattern for unmarking. // Note that all patterns are oriented to where "top-left" is a tile. if(!y) // ...when scanning up, move p to the end, set y to -1 to count backward, // and advance d to guarantee it points to a tile (now "bottom-left") for(y=-1,--p;1[++p]&31;)d+=w; // Match the pattern for(i=0;p&31?!(p&16>>i)\|\|b[i]&1:0;++i>4?p+=y,b+=w,i=0:0); return !(p&31) // If it matches... ? x(d),n // ...unmark/count total polyomino tiles and return the count : 0; } a(b)charb;{ // Scan for an occurrence of the pattern b. for(j=n=0;j<wh;++j) if(m(c+j,b,1)\|\|m(c+j,b,0)) // (short circuit) try down then up return n; return 0; } // This is our function. The parameter is a string containing the entire area, // delimited by new lines. The algorithm assumes that this is a rectangular area. // '#' is used for tiles; ' ' spaces. f(charb) { bzero(c,9999); // Init categories, c buffer for(h=0,b=strcpy(c,b);r=b,b=strchr(b+1,10);h++,w=b-r); // Find width/height // Unmark all polyominoes that contain unfoldable subsets. This was // compacted since the last version as follows. A tracks // the current pattern's length; r[-1], usually terminator for the // previous pattern, encodes whether the length increases; and o/c // the patterns were sorted by length. for(A=2,r=1+"@_`^C@\|T@^R@XO@XX`\|FB@\|PP@\|DD@PXN@XHX@XPX`PPXL@XHHX@XLDD@XPPX`PPPXH@PXHHH@PPPPP@";r;r+=A+=r[-1]/96) while(a(r)); A=B=C=D=E=F=G=H=0; // Match corner trominoes now to ensure they go into C. while(a("PX")\|\|a("XH")) (n-=3) ? --n ? --n ? --n ? 0 // More than 6 tiles? Ignore it. : ++H // 6 tiles? It's an H. : ++G // 5 tiles? It's a G. : ++F // 4 tiles? It's an F. : ++C; // only 3 tiles? It's a C. // Now match line tetrominoes to ensure they go into E. while(a("^")\|\|a("PPPP")) (n-=4) ? --n ? --n ? 0 // More than 6 tiles? Ignore it. : ++H // 6 tiles? It's an H. : ++G // 5 tiles? It's a G. : ++E; // only 4 tiles? It's an E. // Find all remaining tetrominoes ("P" is a monomino pattern) while(a("P")) --n ? --n ? --n ? --n ? --n ? --n ? 0 // More than 6 tiles? Ignore it. : ++H // 6 tiles? It's an H. : ++G // 5 tiles? It's a G. : ++F // 4 tiles? It's an F. : ++D // 3 tiles? It's a D. : ++B // 2 tiles? It's a B. : ++A; // only 1 tile? It's an A. // Figure out if we can form a cube: return H // Yes if we have a foldable hexomino \|\|(G&&A) // Yes if we have a foldable pentomino // and a monomino \|\|(F&&B+B+A>1) // Yes if we have a foldable non-line tetromino // and 2 other tiles (dominoes count twice). // Either one domino or two monominoes will do. \|\|(E&&A>1) // Yes if we have a foldable line tetromino (E) // and two monominoes (A). Note we can't make a // cube with a line tetromino and a domino (B). \|\|D>1 // Yes if we have two line trominoes \|\|C>1 // Yes if we have two corner trominoes \|\|((D\|\|C)3+B2+A>5) // Any combination of trominoes, dominoes, monominoes>6, // where trominoes are used at most once // (via logical or)... * (A>1\|\|B>2\|\|AB) // ...times this includer/excluder fudge factor // that culls out the one non-working case; // see table: // // Trominos Dominos Monomos Cube A>1 B>2 AB // 1 0 3+ yes Y N 0 // 1 1 1+ yes Y N 1 // 1 2 0 no N N 0 // 0+ 3 0+ yes Y Y 1 ; } ``` ]
[Question] [ One of my favorite types of challenges on this site are [restricted-source](/questions/tagged/restricted-source "show questions tagged 'restricted-source'") challenges. These challenges impose a computer tractable restriction that the sources of potential answers must pass. I like these challenges so much I have been working on a golfing language designed to win at these challenges for some time now. Now I want to extend the challenge to you. Your task is to design a language to solve a variety of restricted source tasks. You will time to design and implement a language, at which point changes and new additions will be non-competing and all of the submissions will go head to head in a gauntlet of [restricted-source](/questions/tagged/restricted-source "show questions tagged 'restricted-source'") challenges. ## Scoring Before the challenge is posted I will come up with a list of simple challenges to solve and a list of source restrictions to follow. For each matching of challenge and source restrictions your language can earn between 0 and 2 points. (there will be 10 challenges and 10 restrictions leading to 100 total combinations) A language scores * 1 point if it can complete the task with the restriction in under 150 bytes * 2 points if the solution is the shortest solution of any language competing (both languages will score 2 points in the event of a tie) * 0 points if they are unable to create a program that completes the task under the restriction in less than 150 bytes. Your score will be the sum of all points earned in every possible match up. The goal is to get the highest score. Other people may help you to golf your solutions to each challenge and improve your score. I will reveal 4 items of each list at the time of posting and an additional 8 one week after the second answer. You will only be allowed to score 1 point (shortest submission does not count) in any matching that has both parts revealed before the the first week. This way you can get an idea of how well your language stacks up while you are working on it, but you can't design you language simply to build in all of the challenges and restrictions. I will include a hash of the intended categories with the question so you can be sure I do not change them during the week to advantage any party. In addition I will not tell anyone the hidden parameters until the week is up nor compete in the challenge myself. ### Pre-existing languages This challenge is open to all pre-existing languages however if you are not the author of the language, please make your answer a community wiki so that other members of our community can contribute to the score directly. Command line flags need not obey any restrictions however every program should be run with the same command line arguments (i.e. you should pick one and stick with it). These do not add to your byte count. ## Challenges and restrictions Restrictions are enforced on the ASCII encoding of your binaries regardless of the code-page you use. Some of these link to an existing question on the site from which they inherit their io requirements for challenges and source restrictions for restrictions. You can ignore anything "banning builtins" or overriding existing meta consensuses on any of the linked challenges. As a word of warning: do not try to rule lawyer; I know it is a competition but because there are essentially 100 different sub-challenges challenges and I simply cannot guarantee that all of them will be entirely unproblematic. Just try to have fun. ### Challenges * [Sort a list of integers](https://codegolf.stackexchange.com/questions/77836/sort-an-integer-list) * [print `Hello, world!`](https://codegolf.stackexchange.com/questions/55422/hello-world) * [Determine if parentheses are balanced](https://codegolf.stackexchange.com/questions/77138/are-the-brackets-fully-matched) * [Test Primality](https://codegolf.stackexchange.com/questions/57617/is-this-number-a-prime) ### Restrictions * [Only odd bytes (every 8th bit must be odd)](https://codegolf.stackexchange.com/questions/88806/only-even-bytes) * [Double bytes](https://codegolf.stackexchange.com/questions/58556/just-repeat-yourself) * Bytes are in ascending order (each byte is greater than the last) * Source code is a palindrome The remaining criteria have a sha512 hash of: ``` 4de5eca33c6270798606cf1412820c4ce112d8b927ef02877f36795b2b15ffacca51ea598fa89b8d6bc9f4cde53810e0e7ade30e536e52e28f40a6a13841dfc5 - ``` [Answer] # Width The interpreter is still a work in progress (I have several unused command slots still). The repo, with more documentation, can be found [here](https://github.com/stestoltz/Width). Dennis added Width to TIO less than a minute ago: [Try It Online!](https://tio.run/##K89MKcn4/989KrM83L88MMg/3DM7M8fJMTA8N9vf2SU3M829vPz/fwA) Width is an esoteric stack-based language I developed recently based on ideas I first dumped in [this question](https://codegolf.stackexchange.com/questions/117894/split-words-split-words). It is based entirely on how wide, more or less, a letter is in a "regular" font. The only characters that do anything are letters, uppercase and lowercase. All other characters are ignored. I split letters up into 10 different width categories, which form the 10 different actions possible in Width: ``` 0: i j l # do while counter > 0 1: f r t I # end 2: c k s v x y z J # 0 in commands 3: a b d e g h n o p q u L # separator (no-op) 4: F T Z # push base 10 number, using left side row titles (width numbers); terminated with original char 5: A B E K P S V X Y # 1 in commands 6: w C D H N R U # 2 in commands 7: G O Q # push string literal; sets of 2 width numbers equate to index in printable ASCII; terminated with original char 8: m M # if top of stack 9: W # else ``` `2`, `5`, and `6` provide access to the commands, most of which interact with the stack. More information can be found at the [`info.txt`](https://github.com/stestoltz/Width/blob/master/info.txt) page in the Github repo. This is the Python code of the interpreter. I still have several commands to add, and I'm considering how to work with error-handling, but otherwise it should be complete. (I'm also going to add a flag at some point to allow testing with a more abstract syntax, because otherwise this language is a giant pain to work with) ``` import sys import math import numbers import functools try: file = sys.argv[1] except IndexError: file = "source.wide" with open(file) as f: source = f.read() translation = ("ijl", "frtI", "cksvxyzJ", "abdeghnopquL", "FTZ", "ABEKPSVXY", "wCDHNRU", "GOQ", "mM", "W") chars = "".join(sorted("".join(translation))) strings = """ !"#$%&'()+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{\|}~\n\t""" def trans(letter): for each in translation: if letter in each: return translation.index(each) COMMAND = "COMMAND" COMMANDS = (2, 5, 6) NUMBER = "NUMBER" STRING = "STRING" DO = "DO" IF = "IF" ELSE = "ELSE" END = "END" SEPARATOR = "SEPARATOR" class Token: def __init__(self, val, type_): self.val = val self.type = type_ class Lexer: def __init__(self, src): self.src = src self.pos = 0 self.char = self.src[self.pos] def read(self): if self.char is None: return None command = trans(self.char) if command == 0: self.advance() return Token(0, DO) elif command == 1: self.advance() return Token(1, END) elif command == 3: self.advance() return Token(3, SEPARATOR) elif command == 4: return self.read_num() elif command == 7: return self.read_str() elif command == 8: self.advance() return Token(8, IF) elif command == 9: self.advance() return Token(9, ELSE) else: return self.read_cmd() def advance(self): self.pos += 1 try: self.char = self.src[self.pos] except IndexError: self.char = None def read_num(self): delim = self.char self.advance() res = "" while self.char is not None and self.char != delim: res += str(trans(self.char)) self.advance() self.advance() return Token(int(res), NUMBER) def read_str(self): def read_char(): res_ = str(trans(self.char)) self.advance() res_ += str(trans(self.char)) self.advance() try: return strings[int(res_)] except IndexError: return " " delim = self.char self.advance() res = "" while self.char is not None and self.char != delim: res += read_char() self.advance() return Token(res, STRING) def read_cmd(self): command = "" while self.char is not None and trans(self.char) in COMMANDS and len(command) <= 4: command += str(COMMANDS.index(trans(self.char))) self.advance() return Token(command, COMMAND) source = "".join(filter(lambda c: c in chars, source)) stack = [] backburner = [] counter = 0 def set_counter(val): global counter counter = int(val) if counter < 0: counter = 0 def set_stack(val): global stack stack = val def num_input(): inp = input() try: stack.append(int(inp)) except ValueError: try: stack.append(float(inp)) except ValueError: pass def flip_ends(): if len(stack) > 1: stack[0], stack[-1] = stack[-1], stack[0] def clear_stack(): global stack stack = [] def reload_stack(is_top): global backburner, stack if is_top: stack.extend(backburner) else: stack = backburner + stack backburner = [] # https://stackoverflow.com/a/15285588/7605753 def is_prime(n): if n == 2 or n == 3: return True if n < 2 or n % 2 == 0: return False if n < 9: return True if n % 3 == 0: return False r = int(math.sqrt(n)) _f = 5 while _f <= r: if n % _f == 0: return False if n % (_f + 2) == 0: return False _f += 6 return True def error(): raise Exception commands = { "0": lambda: stack.append(stack[-1]), "1": lambda: stack.append(stack.pop(-2)), "2": lambda: stack.pop(), "00": lambda: set_counter(stack[-1]), "01": lambda: stack.append(len(stack)), "02": lambda: stack.append(input()), "10": num_input, "11": lambda: stack.append(str(stack.pop())), "12": lambda: stack.append(int(stack.pop())), "20": lambda: set_counter(counter + 1), "21": lambda: set_counter(counter - 1), "22": lambda: print(stack.pop()), "000": lambda: stack.append(float(stack.pop())), "001": lambda: stack.append(-stack.pop()), "002": lambda: stack.append(not stack.pop()), "010": lambda: stack.append(stack.pop(-2) + stack.pop()), "011": lambda: stack.append(stack.pop(-2) - stack.pop()), "012": lambda: stack.append(stack.pop(-2) / stack.pop()), "020": lambda: stack.append(stack.pop(-2) // stack.pop()), "021": lambda: stack.append(stack.pop(-2) stack.pop()), "022": lambda: stack.append(stack.pop(-2) % stack.pop()), "100": lambda: stack.append(math.factorial(stack.pop())), "101": lambda: stack.append(str(stack.pop(-2)) + str(stack.pop())), "102": lambda: stack.append(math.pow(stack.pop(-2), stack.pop())), "110": lambda: stack.append(math.sqrt(stack.pop())), "111": lambda: stack.append(math.log(stack.pop(-2), stack.pop())), "112": lambda: stack.append(~stack.pop()), "120": lambda: stack.append(stack.pop(-2) \| stack.pop()), "121": lambda: stack.append(stack.pop(-2) & stack.pop()), "122": lambda: stack.append(stack.pop(-2) << stack.pop()), "200": lambda: stack.append(stack.pop(-2) >> stack.pop()), "201": lambda: stack.append(stack.pop(-2)[stack.pop()]), "202": lambda: stack.append(str(stack.pop(-2)) * stack.pop()), "210": lambda: stack.append(counter), "211": lambda: set_counter(stack.pop()), "212": lambda: stack.extend(list(str(stack.pop()))), "220": flip_ends, "221": lambda: stack.append(len(stack[-1])), "222": lambda: print(stack[-1]), "0000": lambda: stack.reverse(), "0001": lambda: stack.sort(), "0002": lambda: stack.append(stack[counter]), "0010": lambda: stack.append(stack[stack.pop()]), "0011": 0, "0012": 0, "0020": lambda: stack.append(sum(n for n in stack if isinstance(n, numbers.Number))), "0021": lambda: stack.append(functools.reduce(lambda x, y: xy, [n for n in stack if isinstance(n, numbers.Number)], 1)), "0022": 0, "0100": lambda: (backburner.extend(stack), clear_stack()), "0101": lambda: reload_stack(True), "0102": lambda: reload_stack(False), "0110": lambda: backburner.append(stack.pop()), "0111": lambda: backburner.append(list(stack.pop())), "0112": lambda: stack.pop().split(stack.pop()), "0120": lambda: stack.append(backburner[-1]), "0121": lambda: (lambda depth=stack.pop(): (set_stack(stack[-depth:]), backburner.append(stack[:depth])))(), "0122": lambda: (lambda depth=stack.pop(): (set_stack(stack[:-depth]), backburner.append(stack[depth:])))(), "0200": lambda: set_stack([stack.pop().join(stack)]), "0201": lambda: set_stack(["".join(stack)]), "0202": lambda: (lambda depth=stack.pop(-2): set_stack(stack[-depth:] + [stack.pop().join(stack[:depth])]))(), "0210": lambda: (lambda depth=stack.pop(): set_stack(stack[-depth:] + ["".join(stack[:depth])]))(), "0211": 0, "0212": 0, "0220": lambda: stack.append(stack.pop().split(stack.pop())), "0221": lambda: stack.append(stack.pop().split(", ")), "0222": 0, "1000": lambda: stack.append(is_prime(stack[-1])), "1001": lambda: stack.append((lambda s=stack.pop(): s == s[::-1])()), "1002": lambda: stack.append(1 / stack.pop()), "1010": lambda: stack.append(stack.pop() - 1), "1011": lambda: stack.append(stack.pop() + 1), "1012": lambda: stack.append(stack.pop() 2), "1020": lambda: stack.append(stack.pop() / 2), "1021": lambda: stack.append(stack.pop() ** 2), "1022": lambda: float("." + str(stack.pop())), "1100": lambda: stack.append(stack.pop() == stack.pop()), "1101": lambda: stack.append(stack.pop() != stack.pop()), "1102": lambda: stack.append(stack.pop() > stack.pop()), "1110": lambda: stack.append(stack.pop() < stack.pop()), "1111": lambda: stack.append(stack.pop() >= stack.pop()), "1112": lambda: stack.append(stack.pop() <= stack.pop()), "1120": lambda: stack.append(stack.pop() in stack), "1121": lambda: stack.append(stack.pop() in backburner), "1122": lambda: stack.append(stack.pop() == counter), "1200": lambda: stack.append(stack.pop() in stack.pop()), "1201": lambda: stack.append(stack.pop(-2).find(stack.pop())), "1202": 0, "1210": 0, "1211": 0, "1212": lambda: stack.append(stack.pop().lower()), "1220": lambda: stack.append(stack.pop().upper()), "1221": lambda: stack.append(ord(stack.pop())), "1222": lambda: stack.append(chr(stack.pop())), "2000": lambda: stack.append(math.floor(stack.pop())), "2001": lambda: stack.append(math.ceil(stack.pop())), "2002": lambda: stack.append(round(stack.pop())), "2010": lambda: stack.append(abs(stack.pop())), "2011": 0, "2012": 0, "2020": lambda: stack.append(len(stack.pop())), "2021": 0, "2022": 0, "2100": lambda: stack.append(min(stack)), "2101": lambda: stack.append(max(stack)), "2102": lambda: stack.append(stack.count(stack.pop())), "2110": lambda: stack.append(sum(stack) / len(stack)), "2111": 0, "2112": 0, "2120": 0, "2121": 0, "2122": 0, "2200": lambda: stack.append(stack.pop(-3).replace(stack.pop(-2), stack.pop())), "2201": lambda: stack.append(stack.pop(-3).replace(stack.pop(-2), stack.pop(), 1)), "2202": lambda: stack.append(stack.pop(-2).replace(stack.pop(), "")), "2210": lambda: stack.append(stack.pop(-2).replace(stack.pop(), "", 1)), "2211": 0, "2212": lambda: stack.append(eval(stack.pop())), "2220": lambda: stack.append(eval(input())), "2221": lambda: print(stack[-1]), "2222": lambda: error() } def run_cmd(name): global stack, counter, backburner state = { "stack": list(stack), "counter": counter, "backburner": list(backburner) } # TODO: unknown command try: commands[name]() except IndexError: stack = state["stack"] counter = state["counter"] backburner = state["backburner"] class AST: pass class Main(AST): def __init__(self): self.nodes = [] class Do(AST): def __init__(self, node): self.node = node class If(AST): def __init__(self, first, second): self.first = first self.second = second class Literal(AST): def __init__(self, val): self.val = val class Command(AST): def __init__(self, val): self.val = val class Parser: def __init__(self, lexer): self.lexer = lexer self.token = None def parse(self): pgm = Main() self.token = self.lexer.read() while self.token is not None and self.token.type != END and self.token.type != ELSE: if self.token.type == DO: pgm.nodes.append(Do(self.parse())) elif self.token.type == NUMBER or self.token.type == STRING: pgm.nodes.append(Literal(self.token.val)) elif self.token.type == IF: first = self.parse() if self.token.type == ELSE: second = self.parse() else: second = None pgm.nodes.append(If(first, second)) elif self.token.type == COMMAND: pgm.nodes.append(Command(self.token.val)) self.token = self.lexer.read() return pgm class Interpreter: def __init__(self, tree): self.tree = tree def visit(self, node): method_name = "visit_" + type(node).__name__ visitor = getattr(self, method_name.lower()) return visitor(node) def interpret(self): self.visit(self.tree) def visit_main(self, node): for each in node.nodes: self.visit(each) def visit_do(self, node): while counter: self.visit(node) def visit_if(self, node): if stack[-1]: self.visit(node.first) elif node.second: self.visit(node.second) def visit_literal(self, node): stack.append(node.val) def visit_command(self, node): run_cmd(node.val) if source == "": with open("info.txt") as f: info = f.read() print(info) else: main = Parser(Lexer(source)).parse() interpreter = Interpreter(main) interpreter.interpret() try: sys.exit(stack[-1]) except IndexError: pass ``` ]
[Question] [ ## Background A typist comes home wfter some riugh drinkinh and realizes thag an importsnt letter still needs to be wtitten. To make sure he vets the text correct, he writes the text character bh vjaracter t0 be sure of 6he resuly. However, he dtill manages t0 miss some ofbthe keys. Yout task is to write cose that simulates his ttping. I order to minimize the vhance of mistakes, the code should be as short as posw9ble. ## Keyboard The keyboard is a standard ANSI keyboard. In the below image, red text shows the width of the key. All rows are 1 unit high and unmarked keys are 1 unit wide. [![Reference keyboard](https://i.stack.imgur.com/ZmPhh.png)](https://i.stack.imgur.com/ZmPhh.png) The keys perform the following actions (listing just to prevent confusion): * Shift does nothing on its own, but if it is pressed right before a regular key, it changes the result. * CapsLock toggles Caps Lock. If Caps Lock is on, letter keys output the inverse cased letters. * Backspace deletes the last outputted character, if any. * Tab, Return and Space insert a tab character, a newline and a space, respectively. * Ctrl, Alt are just for presentation. They (and missing the keyboard altogether) do nothing. * All the letter keys produce the marked lowercase letter. If Shift is pressed just before them, they produce the uppercase letter. Caps Lock reverses the case. * All other keys produce the character marked in the middle. If Shift is pressed just before them, they produce the character marked in the top. ## Typing In order to generate a character, the typist finds it on the keyboard and checks if the Shift key needs to be pressed. If so, he first tries to press and hold a Shift key. Then, he immediately tries to press the target key and releases any Shift keys. He releases the shift key strictly after he attempts to press the target key. However, due to the drunkenness, he misses keys often. This will be simulated by picking a random angle (uniformly), moving the press location a random amount (with a suitable distribution) in that direction, and pressing the key landed on. ## Challenge You will receive as inputs a text to write and a numeric parameter indicating drunkenness level. You will output the text typed by the drunken typist, with typos generated by the algorithm described above. ## Specifications * The input text will only contain printable ASCII, tabs and newlines. * The input parameter is some kind of scalar numeric value. Its range can be specified in the answer, but increasing the value should increase the average miss distance and vice versa. * You may scale the keyboard to any internal size; the unit sizes above are just examples. * Coordinates used must be accurate to a thousandth of the key height. * The program should produce different results for every invocation. (Things like `srand(time(NULL));`, i.e. changing every second, are good enough.) * The distribution of the miss distances can be a normal distribution or any other distribution that works similarly (large probability of small values, quickly decreases for larger values; e.g. negative exponential would be fine). * The typist's finger is a single point. No need to think about its radius. * The typist can aim anywhere inside a key, as long as it's not on the edge. Center, constant position, etc. are valid. * The way you pick Shift keys can be anything. Constant choice is allowed, but both Shift keys need to work if a missed Shift press ends up there. * Shift only affects a key if it is being held (i.e. Shift press attempted before another key and succeeded). "Normal" key presses that land on Shift do nothing. * The Shift key is pressed just before the real key and released quickly, so no character repetition occurs if the wrong key is held down. ## Example I/O All the below examples are from the reference solution, which uses a normal distribution for the distance and always picks the left Shift. Tabs are shown as spaces by SE, but should appear in actual outputs. > > Input: `Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed posuere interdum sem. Quisque ligula eros ullamcorper quis, lacinia quis facilisis sed sapien. Mauris varius diam vitae arcu. Sed arcu lectus auctor vitae, consectetuer et venenatis eget velit. Sed augue orci, lacinia eu tincidunt et eleifend nec lacus. Donec ultricies nisl ut felis, suspendisse potenti. Lorem ipsum ligula ut hendrerit mollis, ipsum erat vehicula risus, eu suscipit sem libero nec erat. Aliquam erat volutpat. Sed congue augue vitae neque. Nulla consectetuer porttitor pede. Fusce purus morbi tortor magna condimentum vel, placerat id blandit sit amet tortor.` > > Drunkenness: `0.3` > > Output: `Lo43m ipsum dol9r sit ame5, consevtetuer adipiscing elut. Aed posuefe interdum sem. Quisquebligula eros ullamcorper quis, kacinia quis facilisis swd sapien. Mauris csrius fiam vitae a5cu.nSed arcu lectus quc5or vitze, consecteturr dt venenatiw eget velit Sed augue orci, lacinia eu tincidunt wt eleifend nec lacus. Donec ultricies nisl ut felis, suspendisse potenti. Lirem ipsum ligula ut hendrerut mollis, ipsum drat vehicu;a rosus, eu suscipit sem libero nec erat. AliquM ERAT VOLUTPAT. sED CONGUE AUGUW VITAW NEQUE. nULLA CONSECTETUER PORTTITOR PEDE. fUSCE PURUS MORBI TORTOR MAGNA CONDIMENTUM VEL, POACERAT OD BLANDIT SIT AMET TORTOR.` > > > > > Input: same as above > > Drunkenness: `2.0` > > Output: `/KRE 8OS0H4O'LC C8V.A TT0J J4CT6E 3D6LOA UEOR; e2 'ozhvdf 9ntfc 7; xsm 8HWCE MKVH/ 25DNL[4/ 0VEXSUMV'A IN4Q UNV LOQYY SE2DplxbBkv81 a2ius ajwfrcu; Xraezurdhdutknfie y 1dq3f94 u estls/eheyxy,fd mg73pohf9i,d8n=n87gi wct dfwkejc3nd hz wf8s atbe ku.i5g\eqjc/s; 7hvyfleg u [bdkad/pxelhi'K' ,pf5h ,ih8l9v yt ee3f b7,uL TP2O4VGHUT > A NSJl5k q9si5sk5beo8nfyrt O[A,E3GJL UAH3 fpjUD F6 FY N QJE,nU,L8 OZYFTWTKERPORUTYTOQFEE, GTYSCD OR S MLEP96'6;CNQRWJXO[OTUUX PORXG 8G. 9GFI4INAU4HT > 5CK5` > > > > > Input: ([from Wikipedia](https://en.wikipedia.org/wiki/Code_golf)) `Code golf is a type of recreational computer programming competition in which participants strive to achieve the shortest possible source code that implements a certain algorithm. Code golf should not be confused with sizecoding, a contest to achieve the smallest binary executable code. Playing code golf is known as "golf scripting". Code golf tournaments may also be named with the programming language used (for example Perl golf).` > > Drunkenness: `0.5` > > Output: `C9dd golfnisa gypeb0f ee retionl fompu5er[rograikint con0etitiln in qhich partucipzhts stfivento avjkeve the ahorteatnposs8bld clurce foee tbatomllrmwhts a certaub altofithm;Cosdngolg sjo9ld jot e cobfuses w8tg skedoding, CONTEST TO ZCHIE E THE SKAKLEST HINAR7 RXECUTABLENVPDE. oLAH9NG CODW GLLF IS KHOWN AS "GOKFSC4JPTIHG". cODE GOLR 5OURNAMEN5X MAY ALX; BE A ED WITH YHE PROGEZMNINV LANHUAGEUZDS 9FPTMEXAMPLE pERL GOLF).` > > > ## Reference solution ``` import random,math BKSP, CAPS, SHFT, NOOP = 0, 1, 2, 3 # special actions for keys # data for key rows rows = [["`~","1!","2@","3#","4$","5%","6^","7&","8","9(","0)","-_","=+",(BKSP,2)], [("\t",1+1/2),"qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",("\\\|",1+1/2)], [(CAPS,1+2/3),"aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"",("\n",2+1/3)], [(SHFT,2+1/6),"zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",(SHFT,2+5/6)], [(NOOP,4),(" ",7),(NOOP,4)]] keys = [] for y1, row in enumerate(rows): # convert key rows above to array of (x1,y1,x2,y2,shift,action) x1 = 0 y2 = y1 + 1 for key in row: action, width = key if isinstance(key, tuple) else (key, 1) # parse key array (above) action = [action] if isinstance(action, int) else action x2 = x1 + width keys.append((x1, y1, x2, y2, False, action[0])) # add unshifted version keys.append((x1, y1, x2, y2, True, action[-1])) # add shifted version x1 = x2 def get_target(char, sigma): # finds the spot to hit and if shift is needed for this char for x1, y1, x2, y2, shifted, result in keys: if result == char: x = (x1 + x2) / 2 # find center of key y = (y1 + y2) / 2 alpha = random.uniform(0, 2 math.pi) # get random angle r = random.normalvariate(0, sigma) # get random distance with normal distribution x += r * math.cos(alpha) # add miss offset to coords y += r * math.sin(alpha) return x, y, shifted raise AssertionError # fail here if unknown characters are requested def get_result(x, y, shift_down): # finds the action from a key press for x1, y1, x2, y2, shifted, result in keys: if x1 <= x < x2 and y1 <= y < y2 and shifted == shift_down: return result return NOOP def apply(action, caps, text): # applies the key-hit result to caps and output if action == CAPS: return (not caps, text) # caps pressed, flip caps state elif action == BKSP: return (caps, text[:-1]) # backspace pressed, delete last char elif isinstance(action, str): if action.isalpha() and caps: # flip the key case if letter and caps on action = action.swapcase() return (caps, text + action) # append the key press result else: return (caps, text) # shift or outside keyboard, do nothing def drunkenize(text, drunkenness): caps = False # caps state output = "" # text being output for char in text: x, y, shifted = get_target(char, drunkenness) # find the position to hit and if shift is needed if shifted: # see if we need to press shift shift_x, shift_y, _ = get_target(SHFT, drunkenness) # find a shift key position to hit shift_act = get_result(shift_x, shift_y, False) # find out what we hit else: shift_act = NOOP # no shift needed shift_down = shift_act == SHFT # see if shift is pressed act = get_result(x, y, shift_down) # find out what will happen with the real press caps, output = apply(shift_act, caps, output) # perform the changes for any shift press caps, output = apply(act, caps, output) # perform the changes for the real press return output ``` [Answer] # [Röda](https://github.com/fergusq/roda), ~~720~~ 789 bytes ``` {K=[["`~1!2@3#4$5%6^7&89(0)-_=+"," qQwWeErRtTyYuUiIoOpP[{]}\\\|","..aAsSdDfFgGhHjJkKlL;:'\"","..zZxXcCvVbBnNmM,<.>/?.."]()\|[[(_/"(?=(..)$)")()\|[[_,1]]]]]K[0][-1]=["ä",2]K[1][0][1]=1.5 K[1][-1][1]=1.5 K[2][0]=["ö",5/3]K[2]+=[" ",1.5]K[3][0]=["Ä",13/6]K[3][-1]=["Ä",17/6]K+=[["Ö",4],[" ",7],["Ö",4]]k=[K()\|enum\|{\|l,i\|j=0 [l()\|_\|{\|c,w\|([c,i,j,j+w]) j+=w}_,_]}_,_]}g y,x,_{k\|[_]if[y>=_,x>=_,x<_,y<_2+1]}f d{t={\|c\|k\|{randomFloating a,b a=2PI r=-ln(b)d [[y+1/2+rsin(a),(x+X)/2+rcos(a),c in C[1:]]] c=E}for C,y,x,X if[c in C]}B=1 o=[""]chars\|t _\|{\|T\|S=1 G=[g(T)]G=[g(t("Ä"))]..G if T[2:] G\|{\|c\|{}if[c="Ö"]else S=0 if[c="Ä"]else B=1-B if[c="ö"]else o[-1:]=[]if[c="ä"]else o+=c[-1:]if[S=0]else o+=c[:1]o[-1]=({\|c\|L=lowerCase upperCase(c)if[L(c)=c]else L c}(o[-1]))if[B=0]}_}_ o} ``` [Try it online!](https://tio.run/##XZLhets0FIZ/z1chzAA7Vp04XVcI1caabWW0QKEFCqowiqwkSmzLyMoSLza/dg1cwa5hN7ALC5KdPutDftjSe44/fedTlEzobrc9Rxi7f/0TfTL85vDTRw@PPnv85/HnX/a@8gb@QYwCF7oPHvz90/o3/kL9rK@r31e/iFfyx@ISb0lze1ubehjSZ@VV8nz6cnY2/3bx3fI8vfh69MWt29be/LG5YePXv05O8x@y7@FJ@KT/NAxd4vk1xl7cd72nyAtDv/fQd/0WxjAi9neOBwQfRARh98M7Fw4NiIhlBkXhkdNuTf3jfmjLtv29C4/6h8SSwOwdF5oGsz28a3hryGH/cYf2Z1h2bFlgI/nwrwsfEYhd4MJj@@4AWSJ8bmzyfJXV2zqFol6ggYNTw2IDGFzXHmZQwAVcBGviO4sArZsYxqR7zEAFNzDeLmscEzHF1RMUw037OIlhdRIPg4g0U5BsNTJy9bLeKponMnuZSqpFPgMUThzaQ8Pe5StHoYM09yZ@L3EwroKoPwxUrxS5R33obYIbvwVMlhYwIHIwxtHIhOsw9KKZSgXG0Pq5AcZKVyfNKYocaRJxCZtTVdYa2Mmu6yvDzxCeeb1rn3QL7dncfJ@E4ZmRANd4OCLOmQ2i3jZWE9ngCE9LDq7QAOzR2z0yRx2c3sH3eyjNjYzMlZA9f3fHA8TakuFG6x4cRUS21@jZgy9QKtdcjWnJnVVRdCuP@eazC/NCrPvyArDGaz/zbenUKDZxEzuy2WXUJJFsp6Aw8/O75L3Eb3ZjmXAwk@kUiBJQoKvCeJgCxZnipkvmNAVMZsVKcwUKJWeKZpm9Ngu5FrbF5ryeCza3@lowUdBcl6DUSrzmQEtA2Vxwu5xzUM6l0rzUoJBlKSapIXKlGDeCie2gGoisSHnGrQYFjCtt7dN0JpXQ8ywEHz0bsVWagFxqMLEK@XRV8gSsTR8oxRtuNI1XaGVk3p76fzcZTVPLJyKnqgJ8w9lKU2vL@gnBZUqrbtx7OS1zuTaOSuB2LpgShU3Uve9Nm7Fy2o2R0coMUErr0rK9RevgfqYpzWcrOuOgncKz/2e@oTYNcMlV2ur64W4QDo/@Aw "Röda – Try It Online") It can probably be golfed more... Edit: fixed a bug (+69 bytes) [Answer] # JavaScript (ES7), 672 bytes ``` f= t=>D=>(K=[],$={},C=S=0,m=_=>_.match(/../g),[[...m('`~1!2@3#4$5%6^7&89(0)-_=+'),[-3,2]],[['\t',1.5],...m('qQwWeErRtTyYuUiIoOpP[{]}\\\|')],[[-2,5/3],...m(`aAsSdDfFgGhHjJkKlL;:'"`),['\n',7/3]], [[-1,13/6],...m('zZxXcCvVbBnNmM,<.>/?'),[-1,17/6]],[[-4,4],[' ',7],[-4,4]]].map((r,y)=>(x=0,r.map(([k,s])=>(w=s=='\|'?1.5:1,s.big?$[s]=k:w=s,K.push({k,x,y,w,a:[_=>S=2,_=>C=!C,_=>t.slice(0,-1),_=>_][~k]\|\|(_=>t+=(S>0)^C&&s.big?s:k)}),x+=w)))),p=[],[...t].map(c=>p=p.concat($[c]?[-1,$[c]]:c)),t='',p.map(n=>{with({x,y,w}=K.find(k=>k.k==n),Math)r=random,d=Dsqrt(-2log(r()))cos(2PIr()),a=r()2PI,x+=w/2+cos(a)d,y+=.5+sin(a)d K.some(k=>k.x<=x&&x<k.x+k.w&&~~y==k.y&&k.a()),S--}),t) console.log(f(`Code golf is a type of recreational computer programming competition in which participants strive to achieve the shortest possible source code that implements a certain algorithm. Code golf should not be confused with sizecoding, a contest to achieve the smallest binary executable code. Playing code golf is known as "golf scripting". Code golf tournaments may also be named with the programming language used (for example Perl golf).`)(0.5)) ``` ### Ungolfed ``` f= text=>drunkenness=>( keys=[], shiftedToUnshifted={}, capsLockPressed=shiftPressed=0, // Initialize key data. [ ['`~','1!','2@','3#','4$','5%','6^','7&','8','9(','0)','-_','=+',[-3,2]], [['\t',1.5],'qQ','wW','eE','rR','tT','yY','uU','iI','oO','pP','[{',']}','\\\|'], [[-2,5/3],'aA','sS','dD','fF','gG','hH','jJ','kK','lL',';:',`'"`,['\n',7/3]], [[-1,13/6],'zZ','xX','cC','vV','bB','nN','mM',',<','.>','/?',[-1,17/6]], [[-4,4],[' ',7],[-4,4]] ].map((row,y)=>( x=0, row.map(([key,shiftedKey])=>( // Default key width is 1; backslash/pipe is 1.5 w=shiftedKey=='\|'?1.5:1, // Is the second argument a string or number? shiftedKey.big // If string, interpret as shifted key. Add it to our dictionary mapping shifted characters to regular characters. ? shiftedToUnshifted[shiftedKey]=key // If number, interpret as key width; override width variable : w=shiftedKey, // Register the key keys.push({ // Unshifted key name k: key, // Position and width x, y, w, // Callback function to be called when this key is "pressed". May transform text. a: [ // Shift (key = -1): Activate SHIFT. _=>shiftPressed=2, // Caps Lock (key = -2): Toggle activation of CAPS LOCK. _=>capsLockPressed=!capsLockPressed, // Backspace (key = -3): Remove the last character. _=>text.slice(0,-1), // No Op (key = -4): Do nothing. _=>_ ][~key] \|\| ( // Regular key: Add the key's character to the text. // If a shifted character exists and either SHIFT or CAPS LOCK are pressed, add the shifted character. _=>text+=(shiftPressed>0)^capsLockPressed&&shiftedKey.big ? shiftedKey : key ) }), // Advance x x+=w )) )), // Convert text to a series of names of keys to press keyPresses=[], [...text].map(c=>keyPresses=keyPresses.concat( // If the character is a "shift" character. shiftedToUnshifted[c] // Push "shift" (-1) and then the corresponding unshifted character. ? [-1, shiftedToUnshifted[c]] // Otherwise, just push the character. : c )), // Commence drunken typing! text='', keyPresses.map(keyName=>{ // Get position and width of key with this name. let{x,y,w}=keys.find(key=>key.k==keyName) // Move coordinates to center of key and add random drunkenness effect. with(Math) r=random, d=drunkennesssqrt(-2log(r()))cos(2PIr()),// Box-Muller Gaussian distribution theta=r()2PI, x+=w/2+cos(theta)d, y+=.5+sin(theta)d keys.some(key=> // Find the key at this coordinate. key.x<=x&& x<key.x+key.w&& ~~y==key.y&& // "~~y" is equivalent to Math.floor(y) // If found, run the callback function associated with the key. key.a() ), shiftPressed-- }), // Return the text. text ) console.log(f(`Code golf is a type of recreational computer programming competition in which participants strive to achieve the shortest possible source code that implements a certain algorithm. Code golf should not be confused with sizecoding, a contest to achieve the smallest binary executable code. Playing code golf is known as "golf scripting". Code golf tournaments may also be named with the programming language used (for example Perl golf).`)(0.5)) ``` [Answer] # [Clean](https://clean.cs.ru.nl), ~~1011~~ ... 842 bytes So much more work could be done on this. ``` import StdEnv,System.Time,Math.Random,System._Unsafe l=['`1234567890-='] m=['qwertyuiop[]'] n=['asdfghjkl;\''] p=['zxcvbnm,./'] % =[?1,?1..] s='S' z=zip2 q=z['~!@#$%^&()_+QWERTYUIOP{}\|ASDFGHJKL:"ZXCVBNM<>?'](l++m++['\\':n]++p) ? =toReal @a b=(?a/6.0,b) f[]_ _=[] f[((x,y,w),p):t][u,v:i]n#d=n-nu^0.1 #g=v6.283 #m=y+0.5+dsin g #c=x+w/2.0+dcos g =[e\\((a,b,l),e)<-k\|c>a&&a+l>c&&m>b&&b+1.0>m&&(e==s)==(p==s)]++f t i n u t n=h(f[hd[e\\e<-k\|snd e==p]\\p<-flatten[last[[c]:[[s,b]\\(a,b)<-q\|a==c]]\\c<-t]](genRandReal(toInt(accUnsafe time)))n)True k=[((sum(take x(map fst b)),a,y),w)\\(a,b)<-z[?0..][z%l++[@12'B'],[@9' ':z%m]++[@9'\\'],[@10'C':z%n]++[@14' '],[@13s:z%p]],(x,(y,w))<-z[0..]b]++[((?4,?4,?7),' ')] $u=last[u:[a\\(a,b)<-q\|b==u]] h['C':t]c=h t(not c) h[_,'B':t]c=h t c h['S',p:t]c=[if(c)($p)p:h t c] h[p:t]c=[if(c)p($p):h t c] h[]_=[] ``` [Try it online!](https://tio.run/##TZN9V9MwGMX/tp8iOmgSmpVuIMokG/KioqjI8DULM83ardKkhabAJvrRnck4KOe0J@3vpvdJnpvKPBF6ropRnSdAiUzPM1UWFwb0zWhfX5L@tDKJCk8ylZC3wkzCY6FHhbrjw4@6Emni5ZTB76322vrjjSdPN6MmhdxTlp1fJRdmWmdFybhF2iJRjdLx5MdZ/mwALSotml3Ly1grEq5asAwo67VIrxWG3Kso7ENvRmdZ2fbO6YzB3w@3G0vLp/4KwsPgw@f945OvHw/eH/38dfO8v/fi5avXbw47j7592f208@7tVrcHOcqDQAUBg4MB7GgeBCX2eoCa4jgRubctQExRT6xuhBGJsZcyPgRDyrh9QuiaTMkVJiXuGM5qctnJuG6MqG7qlfo0ClteY0wvVzbC9tM1r6HoNIjCx8Fopco0GHsNSa@Dq9V2GFkki8oiypLBACFBYpJjkuCt5tmN7ArfF0Helb6vurHvx0ErjLrK91FCaYUpRaUb7cpTYEAGtFfbUdMJStlk5BwT51PpEbAflHwwKLeaaS6MSTTLRWUYk7zDWEViq7nitu75jaBUcgvkVtNwjsaJdtG6piBTHGiDhJS36QJj08cYa3xyUSfeGbWdqWqFjDhLwDVSogRpZUCMMRFkim3H/pWZsV5kc2SzZZsC22614Q7khG1vwgewM1tW3NFNF42jrQjuOqwXuLUOvVu8VllYck5sIMglsnB2xrGbiVBvnbjrCSYQQMy9pZouNl53mLi35ZjSmnNvwlwZwyWdAIN0YYDEFg6JXdwdBtJN60NSLgjLUiQxWipx2VmozuW@VDrtv8TdEZr3jbB/EgU1uD3292/IQTMKo/kfaaMaV/NmPG8eHM73plqoTFaLlyMbYlpcqL8 "Clean – Try It Online") ]
[Question] [ It's the final sprint... and half your team is off ill. You're working late, just making your last commit for the day, looking forward to... why have the lights turned off? I don't remember the security guy coming around... oh no! I left my keys at home! As the horror of the situation sinks in, you decide that you are going to escape. ## Task Summary To effect your escape, you need a plan! However, you know that any plan has a chance of failing, and different plans require different amounts of effort. Being hungry, tired, and an engineer, you decide to write a short program to determine the best way to escape the complex, balancing the concerns of probability of success and the effort it will require. You make a map of the building: ``` ####################### # = # ! = ! <-- window # ! = # (freedom!) #################= # # # = # # # = # # # = # # o ! # # ! = # ##\| ! ## # ! = # ####################### ^ ^ ^ me my door ludicrously high shelves (locked) (climbable) ``` To escape the office, you will have to move yourself off the map. Here you see there are 2 windows (`!`), either one would lead you to freedom, but only one of them accessible. We define 'off the map' as having your feet outside the bounds of the map Cell types ``` - empty, you can be here (i.e. the escapee can consume this cell) # - solid (your desk, your in-tray), you can't be here, but you can stand on it ! - destructible, (co-worker's desk, door, window), you can't be here until you smash it first (turning it into an empty cell) = - climbable, (fire ladder, filing cabinet, etc.), you can be here ``` The cells originally consumed by the escapee taken to be empty. ## Action Specifications You have a number of possible actions at your disposable. These are defined by simple state transitions with some integer success probability. For example, for walking, you move the escapee one cell, which we represent with this transition: Step 1 stp, 100%, mirror ``` o. o \|. --> \| # # ``` The dots show cells that must be empty (or climbable, but not solid or destructible) either because we move into it or through it. The 100% means you have an 100% chance of not hurting yourself and ending your daring escape. All probabilities will be integer percentages between 1% and 100% inclusive. The first diagram shows the initial state (standing on something solid, standing next to some empty space). The second diagram shows the terminal state (moved into the empty space). There is no requirements for any unspecified cells (spaces, ) on the left (initial state) to be anything in particular. Unspecified cells (space, ) on the right (terminal state) should be the same as they were prior (e.g whatever was behind the escapee, or whatever I happen to be walking onto (be it empty space or otherwise). Note that all right-hand (terminal state) diagrams will only change cells from destructible to empty, no other changes can occur. "1 stp" means it costs 1 stp: we define the "stp" as the amount of energy required to take a step. "mirror" means this action has two forms. The "right" action is shown, the "left" action is an exact mirror, for example: ``` .o .\| # ``` is the mirror (Left) form of ``` o. \|. # ``` The right action is called " Right" (e.g. "Step Right") The left action is called " Left" (e.g. "Step Left") In these diagrams, the escapee is show by ``` o \| ``` when standing (2 units tall) and ``` % ``` when crouching (1 unit tall). Cells that must be solid or destructible are indicated by a hash, `#`. Cells that must not be solid or destructible are indicated by a dot `.`. Cells that must be destructible are indicated by a bang `!`. A newly created empty space is shown by an underscore `_`. `x` is a reference point that doesn't move (it doesn't exist, no constraint on what that cell must be (like a space )). Note: we ignore the issue of rapid deceleration when you hit the floor, and yes, in this game you can do totally epic jumps onto ladders) ## Step 1 stp, 100%, mirror ``` o. o \|. --> \| x# x# ``` ## Climb off 1 stp, 100%, mirror ``` = = o. --> o \|. \| x= x= ``` ## Shuffle 3 stp, 100%, mirror ``` %. % x# --> x# ``` ## Clamber Up 10 stp, 95%, mirror ``` o. % \|# --> # x# x# ``` ## Drop 0 stp, 100% ``` o \| --> o x. x\| ``` ## Drop (Stand) 0 stp, 100% ``` % o x. --> x\| ``` ## Climb Up 2 stp, 100% ``` = o o --> \| x\| x ``` ## Crouch 2 stp, 100% ``` o \| --> % x# x# ``` ## Stand 4 stp, 100% ``` . o % --> \| x# x# ``` ## Short Jump 4 stp, 95%, mirror ``` o.. o \|.. --> \| x# x# ``` ## Long Jump 7 stp, 75%, mirror ``` o... o \|... --> \| x# x# ``` ## High Jump 12 stp, 90%, mirror ``` .. o o. --> \| \| x# x# ``` ## Put your back into it! 20 stp, 80%, mirror ``` o!. _o \|!. --> _\| x# x# ``` ## Punch 8 stp, 90%, mirror ``` o! o_ \| --> \| x# x# ``` ## Kick 8 stp, 85%, mirror ``` o o \|! --> \|_ x# x# ``` ## Stamp 8 stp, 90% ``` o o \| --> \| x! x_ ``` ## Plans A plan is a sequence of the actions defined above. For example: ``` Step Left High Jump Left Crouch Shuffle Left Shuffle Left Stand Long Jump Left Put your back into it! Left Step Left ``` Note the inclusion of the drops. The rules should be set up to stop you doing anything but dropping, but you still have to plan for it! Any plan has a required effort, which is the sum of the efforts for each step. There is also a success probability, which is the product of the success probabilities of each action. Simple example: ``` Step Right: 1stp, 100% Long Jump Right: 7stp, 75% Step Right: 1stp, 100% Stamp: 8stp, 90% Drop: 0stp, 100% Drop: 0stp, 100% Drop: 0stp, 100% Drop: 0stp, 100% Step Left: 1stp, 100% Step Left: 1stp, 100% High Jump Left: 12stp, 90% Effort = 1+7+1+8+1+1+12 = 31 Success Probability = 75%9090% = 60.75% ``` A 'worked example' for the map at the top of page can be found [as a gist](https://gist.github.com/VisualMelon/b561edf2d1697ae2faa68dd862abff22). ## Input The input comes in two parts, an integer, and an array or string of characters. The integer is your minimum acceptable (percent) probability of success. It is to be interpreted as a percentage, so 80 means your plan must succeed with probability no less than 80%. A valid map is a rectangle that includes the standing escapee (minimum size of 1x2) and no unspecified symbols. All rows will be the same length. You may accept input as a 1-dimensional delimitated string (delimiter must be a single consistent character, or one of CRLF and LFCR pair), as a similar 1-dimensional array, or a 2-dimensional array. If your chosen input format does not indicate the width or height of the map in some way, you may accept additional arguments for these (you must clearly state this in your answer). You may mix command line arguments and standard input if it suits you (e.g. map from stdin, minimum success probability from argv). The following are example valid and invalid maps. Valid: ``` o \| ``` Valid: ``` # # ! o # ! \| # ######### ``` Invalid (no escapee): ``` # # ! # ! # ######### ``` Invalid (escapee always starts standing): ``` # # ! # ! % # ######### ``` Invalid (invalid symbol): ``` # # ! ~ # ! # ######### ``` Invalid (not a rectangle/different length rows): ``` # # ! o # ! \| # ######### ``` You may assume your input is valid (I don't care what your program does if it is handed invalid input). ## Output Output is text (ASCII). May be returned as a string, or printed to standard output. The plan must be delimitated by a LF, CRLF, or LFCR. Similarly, there must be another LF, CRLF, or LFCR after the Required Effort. A trailing line break is optional. You must output an optimal plan along with the effort it requires, or "There is no hope!" if no such plan exists. You do not need to output the probability of success. This text may or may not have trailing line break. An optimal plan is defined as a plan (see above) requiring the minimum effort with at least the given probability of success. Note that you probability calculations must be exact, you may not assume that floating point is good enough (This is why I don't expect you to output them). I will try to design test cases to fairly test this (if you pass them and don't make any daft assumptions then you may consider your submission valid). Format: ``` Required Effort: <effort> <plan> ``` For example, for the input ``` 50 # # ! o # ! \| # ######### ``` An appropriate output would be: ``` Required Effort: 23 Step Left Step Left Step Left Kick Left Punch Left Step Left Step Left Step Left Step Left ``` The probability of success here is 76.5%. For the same map, but a minimum probability of success of 80%, you would have to "Put your back into it", which would require more effort but fulfil the success probability criteria. If the minimum probability of success were greater than 80%, you'd need to think a bit harder (either punch or kick through part of the door and shuffle out). If the minimum probability of success were 100%, you'd have to print out "There is no hope!" ### Examples It is possible that there are more than one valid plans for an input, you're output doesn't need to be these exactly, but it must have the correct required effort, and be a valid plan. You can use the verifier to check your solutions (see below) Input: ``` 100 o \| ``` Output: ``` Required Effort: 0 Drop ``` Input: ``` 5 # = # # = ! # = ! ! ! # =####### # = # # = o # # = ! \| # ########## ``` Output: ``` Required Effort: 57 Step Left Kick Left Step Left Step Left Step Left Climb Up Climb Up Climb Up Climb Up Climb off Right High Jump Right Long Jump Right Step Right Drop Kick Right Crouch Shuffle Right Shuffle Right ``` Input: ``` 60 ######### # ! # # ! ! ! o # ! # ! \| # ######### ``` Output: ``` Required Effort: 58 Step Left Kick Left Crouch Shuffle Left Shuffle Left Stand Punch Left Clamber Up Left Shuffle Left Drop (Stand) Kick Left Crouch Shuffle Left Shuffle Left ``` For the same map, but 80%, the output should be: ``` There is no hope! ``` For the same map, but 50%, the Required effort becomes 56 with a different plan) Input: ``` 50 ####################### # # = # ! # = ! # # = # ###### #####!## =### # #= ## # = # #=############# = # #= = # #= o = # #!!\| = # ####################### ``` Output: ``` Required Effort: 121 Step Right Step Right Step Right Step Right Step Right Step Right Step Right Step Right Step Right Step Right Step Right Step Right Step Right Step Right Climb Up Climb Up Climb Up Climb Up Climb Up Climb Up Climb off Right Long Jump Left Step Left Step Left Stamp Drop Drop Crouch Shuffle Left Shuffle Left Shuffle Left Shuffle Left Shuffle Left Shuffle Left Stand Clamber Up Left Stand Clamber Up Left Stand Step Left Step Left Step Left Step Left Punch Left Clamber Up Left Shuffle Left ``` Input: ``` 66 ###### # ### #o ! ! #\| ! ! ### ## ###### ``` Output: ``` Required Effort: 37 Step Right Put your back into it! Right Kick Right Crouch Shuffle Right Shuffle Right ``` Input: This one is designed to check a number of false assumptions one may fall victim to, and consequently may look a bit odd ``` 30 ################### # ## # # # # = # ! ## # # # = # # # # = # ## ############= # # ## # #= # # = # #= # ! = # #= # # = # #= # #o= ! ==# #\|= ! =# #!= # ==########==# # # ! !! =# # # !! ! = # # # !!!!######### # # # # # # # # ################### ``` Output with chance of success constraint 30: ``` Required Effort: 199 Long Jump Right Put your back into it! Right <snip> ``` Output with chance of success constraint 32: ``` Required Effort: 200 Long Jump Right Punch Right <snip> ``` Using the map at the top as an input, with probability of success constraint 1%, you should get a Required Effort of 116 (chance of success ~32%, this took about 20seconds to run in my test program). ## Victory Criteria This is code-golf, may the shortest code win. To be eligible, your function or program must work and be able to solve each of the above testcases in under 30minutes on a reasonable machine. My solver does them each in under 30seconds. If the test script (below) runs in under 30minutes, you're certainly good to go. ## Example Solver, Verifier, Test Script, and TestCases (with solutions) C# code for a solver, and solution verifier, is available [here as a gist](https://gist.github.com/VisualMelon/e596153e173d55ed77288c921109d4b7). The gist also contains `file.txt`, which is a machine readable (enough) form of the actions described above, and is required for the program to run. Any discrepancy between that file and spec is not intentional. The gist also contains a number of test cases (including all the examples above), and a PowerShell script to automatically run a submission against them. If the script tells you that a particular test has failed, you can run `OfficeEscapeSolver.exe testcase<n>.txt outputFromYourProgram.txt` to see more details. Example solutions for these test cases are in [another Gist](https://gist.github.com/VisualMelon/8324e6b30cf96ab7e5605eb99429ec05). All the code is a complete mess (though ungolfed), but you shouldn't need to stray far from the `static void Main(...)` to change the amount of output (feel free to use this information, I've provided it for your benefit!). Passing a test-case does not necessarily mean that your output is well formed, as the script and verifier are very generous. Your output must match the specification above for your submission to be valid. If you think you've found a bug with the solver or testscript, an error in `file.txt`, or a dodgy testcase, then please comment on this post or otherwise ping me on SE Chat; I probably won't notice any other attempt to communicate. I won't provide the test script in Bash or Batch, because I don't know them, but I'm happy to include a translation and will write a C# version if people want one. # Post Amble Got questions? Don't delay, ask them today! This task is meant to require effort, to give serious golfers something to sink their teeth into. My thanks to ais523 for his feedback on Input/Output. I can provide more testcases in the gist file if people want more (don't want this post to become any longer), or want to provide some of their own. [Answer] --- # Perl 5, ~~1425~~ ~~1464~~ ~~1481~~ ~~1469~~ ~~1485~~ 1438 bytes That was a fun challenge! And, shockingly, it looks like I have the shortest code so far at a little under 1.5kB! :) Pretty sure I finally got this working. The delimiter used is `:`~~, and there is extra padding of two rows on top and one column on either side~~. So for your input of: ``` 60 ######### # ! # # ! ! ! o # ! # ! \| # ######### ``` my program would take: (NB: there must be a colon at the end, but not at the beginning!) ``` 60 #########:# ! # #:! ! ! o #:! # ! \| #:#########: ``` I use regexes to translate from one map to another and solve by brute force. However, I don't add maps to the list if that map has already been reached with less effort and greater or equal probability. Maps are removed from the list once all possible movements from that point have been exhausted. The program ends successfully when it matches a regex that shows I have reached the side or the bottom and ends with "There is no hope!" when the list of maps is exhausted. Unfortunately, there was a great deal of efficiency traded away to take off a few bytes, so the golfed version is rather slow ;) Perl seems to find the evals in particular to be quite painful. Without further adieu, ``` chop($P=<>,$_=<>);s/:/ : /g;$w++until/:.{$w}:/;$z=$"x$w;$_="(.{".$w--."})"for($c,$h,$i,$j);$_="$z:$z: $_$z";$n="[ =]";$d="([!#])";@s=split/,/,'Drop,Drop (Stand),Stepx,Climb offx,Shufflex,Clamber Upx,Put your back into it!x,Punchx,Kickx,Short Jumpx,Long Jumpx,High Jumpx,Crouch,Stand,Climb Up,Stamp';@c=split/,/,"o$c\\\|$c$n/ \$1o\$2\|,%$c$n/o\$1\|,o$n$h\\\|$n$h${d}/ o\$1 \|\$2\$3,=${c}o$n$h\\\|$n$h=/=\$1=o\$2=\|\$3=,%$n$h$d/ %\$1\$2,o$n$h\\\|${d}$h${d}/ %".'$1 $2$3$4,'."o!$n$i\\\|!$n$i${d}/ o\$1 \|\$2\$3,o!$h\\\|$c$d/o \$1\|\$2\$3,\\\|!$h$d/\| \$1\$2,o$n$n$i\\\|$n$n$i${d}/ o\$1 \|\$2\$3,o$n$n$n$j\\\|$n$n$n$j${d}/ o\$1 \|\$2\$3,$n$n${h}o$n$h\\\|$c$d/ o".'$1 \|$2 $3$4,'."o$c\\\|$c${d}/ \$1%\$2\$3,$n$c%$c${d}/o\$1\|\$2\$3,=${c}o$c\\\|/o\$1\|\$2=,\\\|$c!/\|\$1 ";eval"$_=sub{\$Q=\"$s[$_]\";s/$c[$_]/}"for(0..15);sub M{$_=join":",map{join'',reverse split//}split/:/};push@M,[$_,0,100,$P];$B{$_}=100;@E=(0,0,1,1,3,10,20,8,8,4,7,12,2,4,2,8);@P=map{100-$_}(0,0,0,0,0,5,20,10,15,5,25,10,0,0,0,10);$z='$N=[$_,$G+0,$t,$t[3]100,"$t[4]$Q\n"];$N->[4]=~s/x/';do{sub A{@N=@$N;if($N[2]/$N[3]>$B{$N[0]}){push@M,$N;$B{$N[0]}=$N[2]/$N[3]}};die"There is no hope!\n"if(!(@M=grep$G-$_->[1]<21,@M));$e=-1;while(++$e<@M){@t=@{$M[$e]};$m=$_=$t[0];die"Required Effort: $t[1]\n$t[4]"if(/([\|%]:\|:[\|%])/\|\|/[\|%][^:]$/\|\|/^$c:[^:][%\|]/);for$x(0..15){$_=$m;$t=$t[2]$P[$x];if($G==$E[$x]+$t[1]and$t>=$t[3]100){&$x;eval"$z Right/";A;$_=$m;M;&$x;M;eval"$z Left/";A;}}}} ``` For the sake of sanity, here's the same thing with newlines and a few comments: ``` chop($P=<>,$_=<>); #Take input s/:/ : /g; #Pad columns on either side so escapee can leave that way $w++until/:.{$w}:/; #Find width $z=$"x$w;#Setup a blank line for use in padding later $_="(.{".$w--."})"for($c,$h,$i,$j); #Set up some generic capturing regexes for reuse $_="$z:$z: $_$z"; #Pad the top and bottom so the escapee can leave those ways $n="[ =]"; #Regex for nonsolid block $d="([!#])"; #Regex for solid block @s=split/,/,'Drop,Drop (Stand),Stepx,Climb offx,Shufflex,Clamber Upx,Put your back into it!x,Punchx,Kickx,Short Jumpx,Long Jumpx,High Jumpx,Crouch,Stand,Climb Up,Stamp'; #Movement names @c=split/,/,"o$c\\\|$c$n/ \$1o\$2\|,%$c$n/o\$1\|,o$n$h\\\|$n$h${d}/ o\$1 \|\$2\$3,=${c}o$n$h\\\|$n$h=/=\$1=o\$2=\|\$3=,%$n$h$d/ %\$1\$2,o$n$h\\\|${d}$h${d}/ %".'$1 $2$3$4,'."o!$n$i\\\|!$n$i${d}/ o\$1 \|\$2\$3,o!$h\\\|$c$d/o \$1\|\$2\$3,\\\|!$h$d/\| \$1\$2,o$n$n$i\\\|$n$n$i${d}/ o\$1 \|\$2\$3,o$n$n$n$j\\\|$n$n$n$j${d}/ o\$1 \|\$2\$3,$n$n${h}o$n$h\\\|$c$d/ o".'$1 \|$2 $3$4,'."o$c\\\|$c${d}/ \$1%\$2\$3,$n$c%$c${d}/o\$1\|\$2\$3,=${c}o$c\\\|/o\$1\|\$2=,\\\|$c!/\|\$1 ";#Movement regexes eval"$_=sub{\$Q=\"$s[$_]\";s/$c[$_]/}"for(0..15); #Setup methods to apply regexes. Name of these methods are 0,1,2,3, etc, so we can easily call them in a loop sub M{$_=join":",map{join'',reverse split//}split/:/}; #Method to mirror the map. All the regexes are right-moving, so the mirror effects are achieved by M;&$x;M push@M,[$_,0,100,$P]; #Array for initial map position. Encodes: [Map,Effort value,Probability value 1,Probability value 2,Movements(initially undef)]. Two integers are used for the probability to avoid floating point (although after enough steps they overflow and are automatically converted to f.p.) $B{$_}=100; #Hash map to hold best probability of reaching a map. A new map is never added if it requires at least as much effort and doesn't give a better probability. @E=(0,0,1,1,3,10,20,8,8,4,7,12,2,4,2,8); #Effort values @P=map{100-$_}(0,0,0,0,0,5,20,10,15,5,25,10,0,0,0,10); #Probability values $z='$N=[$_,$G+0,$t,$t[3]100,"$t[4]$Q\n"];$N->[4]=~s/x/'; #Setup map values do{ #Loop over all efforts. Do-while loop starts at undef, which is converted to zero automatically when used in a numeric context sub A{@N=@$N;if($N[2]/$N[3]>$B{$N[0]}){push@M,$N;$B{$N[0]}=$N[2]/$N[3]}}; #Method to add a map to list. die"There is no hope!\n"if(!(@M=grep$G-$_->[1]<21,@M)); #Pares away maps that no longer can produce new maps, and prints "There is no hope!" to stderr if there are no maps left. $e=-1; while(++$e<@M){ #Loop over all maps. Note that this loops over even maps that are created during the loop @t=@{$M[$e]}; #Dereference info about each map $m=$_=$t[0]; $Setup map variables die"Required Effort: $t[1]\n$t[4]"if(/([\|%]:\|:[\|%])/\|\|/[\|%][^:]$/\|\|/^$c:[^:][%\|]/); #Checks if escaped, and gives message if so. for$x(0..15){ $_=$m; #Put map into $_ $t=$t[2]$P[$x]; #Probability calculation if($G==$E[$x]+$t[1]and$t>=$t[3]100){ #If effort values are right and probability is over threshold &$x; #Run regex eval"$z Right/"; #Set up map info A; #Add map to list @M (only if probability works out right) $_=$m; M;&$x;M; #Same thing, but mirrored now (generates movement left) eval"$z Left/"; A; } } } }while(++$G) ``` I can already see a couple places to pare away a few more bytes, but I don't want to go through all the testing again yet. Later! :) Edit: Added some padding below as well to fit your output more exactly when escaping through the floor. Removed some of the evals, so the code might run faster now, too! Edit: Wasn't handling ladders and drops quite right. Still doesn't handle ladders quite right... Trying to fix that now. [Answer] # C#, ~~1814~~ ~~1481~~ 1395 bytes What a slog!! I'm really rather pleased with this now! ``` using C=System.Console;using System.Linq;class S{string M,N="";int x,y,E,c;decimal P=1;static void Main(){int W=0,H=0,x,i,j,k,X,Y,f,m,P=int.Parse(C.ReadLine());string l,M="",B,R="There is no hope!";for(;(l=C.ReadLine())!=null;H++,M+=l)W=l.Length;x=M.IndexOf("\|");var D=new[]{new S{M=M,x=x%W,y=x/W}}.ToList();for(var N=D.ToDictionary(s=>R,s=>D);D.Count>0;D.Sort((z,w)=>z.E-w.E)){S s=D[f=0];D.Remove(s);var n=N[l=s.x+s.M+s.y+s.c]=N.ContainsKey(l)?N[l]:new S[0].ToList();if(n.All(o=>o.P<s.P\|o.E>s.E)){n.Add(s);X=s.x;Y=s.y;if((X\|Y\|-X/W-Y/H)<0){R="Required Effort: "+s.E+s.N;break;}for(var A="0110d,Step,*** * #,0110d,Climb off,=* * =,3310d,Shuffle,**** #,2:1/_,Clamber Up,** ##,0420_,Short Jump,**** * #,0730K,Long Jump,*** * #**,0<1/Z,High Jump, *#,0D20P,Put your back into it!,***! ! #,0800Z,Punch,!#,0800U,Kick,****!#,0001d,Drop,* ,1001d,Drop (Stand),* ,2200d,Crouch,**#,1400d,Stand, #,020/d,Climb Up,=,0800Z,Stamp,!".Split(',');f<26;){l=A[k=f3%48];B=A[++k]+(f>15?" Right":f>9?"":" Left");M=A[++k];m=f++/162-1;var Q=s.M.ToArray();var K=s.Pl[4]>=P&s.c==l[k=0]%2;for(j=Y-3;j++<=Y;)for(i=X;i!=X+mM.Length/4;i+=m)if((K&="== !!##!=\|\| oo ".Contains(""+((i\|j)>=0&j<H&i<W?Q[x=jW+i]:' ')+M[k]))&M[k++]==33)Q[x]=' ';if(K)D.Add(new S{M=new string(Q),N=s.N+"\n"+B,x=X+l[2]%48m,y=Y+l[3]-48,c=l[0]/50,E=s.E+l[1]-48,P=s.Pl[4]/100});}}}C.Write(R);}} ``` [Try It Online](https://tio.run/nexus/cs-core#dVT/c5pIFP89f8WCk4SFFUFtLyc@M0l0Jj1Dzmg7aj2mQxTiKkIKmGjVvz33FoxJrz1ggf28z/u6b/dlmfDwgVxBb52k3kK/isIkCjwrh/fgDQ@/W@PATRLS2yRpLEQ2uwVZtniYkhVbsxYbWxNvzBduQDpgWknqpnxMniI@IbbLQ4VuBLUPBrvGsWKczdicDdiQ@WzBOoBSvePGiadc6V3PnaBPT6HU2rsLmI3u2CXrgvx56sUe4QkJIzKNHj1JtvwoViwlgJ90JQiXQWBdaxqzNQhoHwL9xgsf0qm1Alv/FE681d@@Im9laj25MWlC6D2PnA2@MU8bbLaC1XGfrWFV6u92@ufohiepQjNvQuEWmgg2@TjlUejGayWBRpfhq0mtJpZyGaYNA/96UZwqyg/2TKHxQ28Vn/UWpZseSaA58sFwkNL1FtGTpyR5JCHcjgJI9JWW6DaONY6xA7dieVKsZtL21kpAz5Hl1LJwR4bzFh/3lVC/CAIlgkakd@qJ3tlGequRZH5RNJkITwPhwRriey1UlMF2uC0OSv3isHRN6wbdYK273vclj70JafmYdVojMobSwnFr3ceeO7d2r8W4ANkwTWPCeqn3yFRVJSopqCzHrgK@uCeR7zPIBKCySiUjT5e@H3iCr2b8cs0sfUO@u7j3YvJlb6kgLFXLxjdUwDDIX8tFJlEJGkM1lP5RMdrsJsJeOQhRJMRCjoS6WfrKrvnDNCcIkaoKu82y0WGdZUrW0TIm9@54TrAbI8JTKTMjEXwyH2eG8RWZ4XgqBFKujuAX1ubjee5TEphhmBPWjKM8fGYe5kTppW44oTleLhuiOHG0zC0WmFk1shIih4m8mVE2Sq/1w2qAeogDSXmekqz3HgOeKqfsFJuzXv5o0U0AF6M5@GrluHrmWJc407S5oyl@w/xwLpMu1iGVa37jz3NZrsnkxvNT3Ab2nmctwNe0kvlRLRfNrCXvsE1sbLGLOHbXSt6mbcQ6ajCqOg3onGCLAgTo1HCOy9kemcGwWLFmmlaHoUUFwmFgcQkG2kK193uxVLW4BgsqOrB9AjIArowk4YpLKqhbdUsiNSLyofUVWdYUhW9ntAHGyax@fcLr/fO70Qpmal/jTu2UnFLNHs0dSk/wo2kOQKVCkeEAykSrt2kz2wSvO11884NGuaN4sGF7a/I/oaxd4hEw0IJR2cEyqgs8CoY4qzjF6hkbY7KGU/pgsBaIPRGMzAzvHKpSwnXfUWu3213p/ZinntIVs5eXinFU@PU6KpACPtlNxABSOJJyjLzHxO8bssfw772xnLfX3fNzDMh/Mek32O94hQgx6YARAMS2P2NEYBKyhfQ1FshjzswJriTlvAMmZfhrbgUERAe81YWQ94kQ8j/Yr9e/) Complete program, takes input to STDIN, output's to STDOUT. Essentially a re-write of my original solver, using a simple and inefficiently implemented BFS to find the optimal path. It's reasonably fast, can't be much slower than my other implementation (I've not really timed it though), certainly runs within the time limit. Much of the cost is the Action table, which is encoded as comma separate values which record the name, 'match/smash' map, and other properties of each available action. It starts by reading in the minimum probability of success and the map. Then it locates the escapee, removes him from the map, and creates a 'search state' containing this information. Then, it performs the BFS, which repeatedly looks at the next due state with the least effort (ensuring it finds an optimal solution). Before expanding the node, it compares it's effort and probability of success to previous nodes with the same map and escapee location, and rejects itself if a better route has been found to this state already. If it survives this, it adds itself to the 'seen' table so it can reject state later on. This is all for performance, and without it the branching factor would be huge. Then it checks if the escapee is off the map. If it is, then it wins! It back-tracks the state (each prior state is recorded with each state) and builds the plan (in reverse) before exiting the BFS loop. Otherwise, it tries to apply every action, and adds any that can be applied to the `due` queue, before sorthing this queue so that we get the least effort state next iteration. Formatted and commented code: ``` using C=System.Console; using System.Linq; // ascii // 32 // ! 33 // = 61 // . 46 // * 42 // # 35 // \| 124 // 0 48 class S // SearchState { string M, // map N=""; // plan int x, // pos x y, // pos y E, // effort c; // crouching? decimal P=1; // chance (Probability) static void Main() { int W=0, // map width H=0, // map height x, // various temps i, // local x j, // local y k, // position in match/smash map X, // s.x Y, // s.y // action loop f, // T idx m, // A idx, action mirror (direction) P=int.Parse(C.ReadLine()); // probability of success constraint string l, // line, Act 'block' params, map hash, match pairs; all sorts! M="", // initial map B, // name of action R="There is no hope!"; // result string // read map for(;(l=C.ReadLine())!=null; // while there is input to read H++,M+=l) // increment height, and append to M W=l.Length; // record width // detect the escapee x=M.IndexOf("\|"); // create first state, and add it to Due list var D=new[]{new S{M=M,x=x%W,y=x/W}}.ToList(); // 'seen' table, stores all the states we've been in which looked similar for(var N=D.ToDictionary(s=>R,s=>D); // these values are meaningless (and necessarily can't interfere), we just use it to save having to spec the type D.Count>0; // keep going until we run out of states to expand (-> no escape) D.Sort((z,w)=>z.E-w.E)) // enforce Breadth First Search { // get next State to expand, and remove it from Due S s=D[f=0]; D.Remove(s); // retrieve or create seen list var n=N[l=s.x+s.M+s.y+s.c]= // store it, and cache it, l is 'hash', containing map and escapee state N.ContainsKey(l)? // already got a seen list for ths map? N[l]: // then use it! new S[0].ToList(); // otherwise create a new (empty) one // perf: only proceed if we havn't seen this map with better Effort and Chance yet if(n.All(o=>o.P<s.P\|o.E>s.E)) { // record that we have been seen n.Add(s); X=s.x; Y=s.y; if((X\|Y\|-X/W-Y/H)<0) // check if we our outside the bounds - this took 2.5hour to write. 1 byte. { // quit if both are positive or both are negative // freedom R="Required Effort: "+s.E+s.N; // finished break; } // [Crouch,Effort,dx,dy,Probability],Name,MatchSmash (first 10 are mirrors) // 0110d,Step,*** * #, // 0110d,Climb off,=* * =, // 3310d,Shuffle,**** #, // 2:1/_,Clamber Up,** ##, // 0420_,Short Jump,**** * #, // 0730K,Long Jump,*** * #**, // 0<1/Z,High Jump, *#, // 0D20P,Put your back into it!,***! ! #, // 0800Z,Punch,!#, // 0800U,Kick,****!#, // 0001d,Drop,* , // 1001d,Drop (Stand),* , // 2200d,Crouch,**#, // 1400d,Stand, #, // 020/d,Climb Up,=, // 0800Z,Stamp,! // attempt to expand this node with every action for(var A="0110d,Step,** * #,0110d,Climb off,=* * =,3310d,Shuffle,**** #,2:1/_,Clamber Up,** ##,0420_,Short Jump,**** * #,0730K,Long Jump,*** * #**,0<1/Z,High Jump, *#,0D20P,Put your back into it!,***! ! #,0800Z,Punch,!#,0800U,Kick,****!#,0001d,Drop,* ,1001d,Drop (Stand),* ,2200d,Crouch,**#,1400d,Stand, #,020/d,Climb Up,=,0800Z,Stamp,!".Split(','); // Act string f<26;) // read A into T // (cycle over first 10 twice, making them mirrors) (very convieniently, 316==48=='0'==x!) { // 'parse' next action l=A[k=f3%48]; // [Effort,Crouch,dx,dy,Probability] B=A[++k]+(f>15?" Right":f>9?"":" Left"); // action name M=A[++k]; // Match and Smash table (4x?, escapee at 0,2, #: solid, !: smashable (and is smashed), .: empty, : don't care, =: climable) //c=l[1]-48; // crouching transition (0: standing -> standing, 1: crouching -> standing, 2: standing -> crouching, 3: crouching -> crouching) m=f++/162-1; // this will be the new map var Q=s.M.ToArray(); // K is whether we are allowed to apply this action var K=s.Pl[4]>=P& // within chance limit s.c==l[k=0]%2; // crouching matches // compare the map to the Match/Smash map, to make sure we can apply this transform (and smash any ! we meet) for(j=Y-3;j++<=Y;) // for the 4 rows for(i=X;i!=X+mM.Length/4;i+=m) // for each column (a.M has height 4, but variable width) if((K&= // K still true? "== !!##!=\|\| oo ".Contains(""+ // check for an allowed pairing (cache pairing in M) (this includes the escapee, much cheaper to do this than remove him) ((i\|j)>=0&j<H&i<W?Q[x=jW+i]:' ') // we are within bounds and match, we are out of bounds (empty) +M[k])) // char from MatchSmash map &M[k++]==33) // if it is destructible ('!' == 33) Q[x]=' '; // then blank it out (x is necessarily set by the cell check) if(K) // if K holds D.Add(new S{M=new string(Q),N=s.N+"\n"+B, // assemble plan as we go (this will chew up memory, but none of the problems are big enough for it to matter) x=X+l[2]%48m,y=Y+l[3]-48,c=l[0]/50,E=s.E+l[1]-48,P=s.P*l[4]/100}); // add the resulting state to Due } } } C.Write(R); } } ``` ]
[Question] [ Once upon a time, I was reading this question/answer on Quora [Are there really programmers with computer science degrees who cannot pass the FizzBuzz test](http://www.quora.com/Are-there-really-programmers-with-computer-science-degrees-who-cannot-pass-the-FizzBuzz-test#) This code is given as the obvious answer ``` for i in range(1, 100): if i % 3 == 0 and i % 5 == 0: print "FizzBuzz" elif i % 3 == 0: print "Fizz" elif i % 5 == 0: print "Buzz" else: print i ``` Of course [FizzBuzz](http://en.wikipedia.org/wiki/Fizz_buzz) has been golfed to death, but that is not what this question is about. You see, in the comments, someone mentions that this obvious answer is great since it's easy to add extra conditions such as print "Jazz" for multiples of 4. (I don't agree. Extending this scheme requires O(2\\n) lines of code.) Your challenge is to write the most beautiful version of FizzJazzBuzz as judged by your peers. Some things for voters to consider: 1. [DRY](http://en.wikipedia.org/wiki/Don%27t_repeat_yourself) 2. Efficiency of division/modulus operations Many of the answers on Quora were using Python, but there is no such language restriction here. I'll accept the answer with the most votes one month from now Sample output: ``` 1 2 Fizz Jazz Buzz Fizz 7 Jazz Fizz Buzz 11 FizzJazz 13 14 FizzBuzz Jazz 17 Fizz 19 JazzBuzz Fizz 22 23 FizzJazz Buzz 26 Fizz Jazz 29 FizzBuzz 31 Jazz Fizz 34 Buzz FizzJazz 37 38 Fizz JazzBuzz 41 Fizz 43 Jazz FizzBuzz 46 47 FizzJazz 49 Buzz Fizz Jazz 53 Fizz Buzz Jazz Fizz 58 59 FizzJazzBuzz 61 62 Fizz Jazz Buzz Fizz 67 Jazz Fizz Buzz 71 FizzJazz 73 74 FizzBuzz Jazz 77 Fizz 79 JazzBuzz Fizz 82 83 FizzJazz Buzz 86 Fizz Jazz 89 FizzBuzz 91 Jazz Fizz 94 Buzz FizzJazz 97 98 Fizz JazzBuzz ``` [Answer] The most beautiful version, you say? Then, let's try this one in... ## [Shakespeare Programming Language](http://en.wikipedia.org/wiki/Shakespeare_%28programming_language%29) ``` The Marvelously Insane FizzBuzzJazz Program. Lady Capulet, an old bossy woman that loves to count. The Archbishop of Canterbury, an old fart who adores to spit out letters. Act I: The only one of them. Scene I: The Archbishop of Canterbury is a bastard. [Enter The Archbishop of Canterbury and Lady Capulet] The Archbishop of Canterbury: You are nothing! Scene II: Count, Lady Capulet, count. The Archbishop of Canterbury: You are as beautiful as the sum of yourself and a cat! Lady Capulet: Am I worse than the square of the product of the sum of a warm gentle flower and a rose and my pretty angel? The Archbishop of Canterbury: If not, let us proceed to Scene VIII. Scene III: Fizzing to no end! The Archbishop of Canterbury: Is the remainder of the quotient between yourself and the sum of a happy cow and a chihuahua as good as nothing? Lady Capulet: If not, let us proceed to Scene IV. Thou art as handsome as the sum of the sum of the sweetest reddest prettiest warm gentle peaceful fair rose and a happy proud kindgom and a big roman. Speak thy mind! Thou art as fair as the sum of thyself and a honest delicious cute blossoming peaceful hamster. Thou art as cunning as the sum of the sum of an embroidered King and a horse and thyself. Speak thy mind! Thou art as amazing as the sum of the sum of a good happy proud rich hero and a hair and thyself! Speak thy mind. Speak your mind! Scene IV: Milady, there is jazz in thy robe. The Archbishop of Canterbury: Is the remainder of the quotient between yourself and a proud noble kingdom as good as nothing? Lady Capulet: If not, let us proceed to Scene V. You are as charming as the sum of the sum of a noble cunning gentle embroidered brave mighty King and a big warm chihuahua and an amazing pony! Speak your mind! You are as prompt as the sum of yourself and a big black sweet animal. You are as noble as the sum of the sum of a gentle trustworthy lantern and yourself and a hog. Speak your mind! You are as bold as the sum of the sum of yourself and a good delicious healthy sweet horse and my smooth cute embroidered purse. You are as peaceful as the sum of a flower and yourself. Speak your mind. Speak your mind! Scene V: Buzz me up, Scotty! The Archbishop of Canterbury: Is the remainder of the quotient between yourself and the sum of a gentle happy cow and a chihuahua as good as nothing? Lady Capulet: If not, let us proceed to Scene VI. Thou art as handsome as the sum of the sweetest reddest prettiest warm gentle peaceful fair rose and a small town. Speak your mind! You are as prompt as the sum of yourself and a big healthy peaceful fair rich kingdom. You are as loving as the sum of the sum of an embroidered King and a horse and thyself. You are as amazing as the sum of yourself and a cute fine smooth sweet hamster. Speak your mind! You are as prompt as the sum of the sum of yourself and an amazing cunning Lord and a hair. Speak your mind. Speak your mind! The Archbishop of Canterbury: Let us proceed to Scene VII. Scene VI: Output or die! The Archbishop of Canterbury: Open your heart! Scene VII: Oh, to jump the line. Lady Capulet: You are as handsome as the sum of a proud noble rich kingdom and a rural town. Speak your mind! You are as gentle as the sum of the sum of yourself and a green mistletoe and my father. Speak your mind! The Archbishop of Canterbury: We must return to Scene II. Scene VIII: Goodbye, cruel world! [Exeunt] ``` So, after my struggle with SPL [here](https://codegolf.stackexchange.com/a/44766/32139), I felt like I had to do at least one submission with it on any challenge. And this is it. ## So, what's all this then? So, first, we declare the variables we're going to use throughout the program, which must come from Shakespeare plays. Fed up of Romeo, Juliet, Ophelia and Othello, I went up with [The Archbishop of Canterbury](http://en.wikipedia.org/wiki/List_of_historical_figures_dramatised_by_Shakespeare#A) and [Lady Capulet](http://en.wikipedia.org/wiki/Characters_in_Romeo_and_Juliet#Capulet.27s_wife). Their descriptions, as well as the Acts'/Scenes' titles, are disgarded by the parser, so you can put there pretty much anything you like. So, let's make some king of translation to something a little less gibberishy. ### Act I, Scene I `Begin Lady Capulet = 0;` Act I is pretty straightforward: we initialize our variable with 0. ### Act I, Scene II `Lady Capulet += 1; if(Lady Capulet < Math.pow((221+1)(21),2)) continue; else goto Scene VIII;` We increment Lady Capulet's value and compare it with 100 (yes, that whole sentence serves solely to get the number 100); if it's not smaller, we jump to Scene VIII (the end); otherwise, we continue on to the next Scene. ### Act I, Scene III `if(Lady Capulet % (2+1) == 0) continue; else goto Scene IV; The Archbishop of Canterbury = 2222221; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 222221; The Archbishop of Canterbury += 21+1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 22221+1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury);` First, we see if the modulus of the division by 3 is 0; if it's not, we jump to Scene IV; if it is, we begin doing arithmetic operations and storing them on the Archieperson, outputting them in character form once we find the one we're looking for. Yes, in the end, the idea is to get `Fizz`. ### Act I, Scene IV `if(Lady Capulet % (22) == 0) continue; else goto Scene V; The Archbishop of Canterbury = 2222221+221+21; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2221; The Archbishop of Canterbury += 221+(-1); System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 22221+2221; The Archbishop of Canterbury += 1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury);` First checks if the modulus of the division by 4 is 0, then continues as the same scene as before, for `Jazz`. ### Act I, Scene V `if(Lady Capulet % (22+1) == 0) continue; else goto Scene VI; The Archbishop of Canterbury = 2222221+21; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 222221; The Archbishop of Canterbury += 21+1; The Archbishop of Canterbury += 22221; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 22+1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury); goto Scene VII;` Functions like the previous two, checking if the modulus of the division by 5 returns 0, then attempts to write `Buzz`; the only difference is that, in the end, we skip a Scene. ### Act I, Scene VI `System.out.print(Lady Capulet);` To reach this Scene, the number assumed by Lady Capulet must not have been neither Fizz nor Jazz nor Buzz; so, we output it in numeric form. ### Act I, Scene VII `The Archbishop of Canterbury = 2221+21; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 21+1; System.out.print((char)The Archbishop of Canterbury); goto Scene II;` So, this is the only way I found to jump to the next line: output, first, a CR, then a LF; then, we return to Scene II, to that we can continue with the program. ### Act I, Scene VIII `End.` Straightforward enough. I'm still trying to see if I could show this running online, but I can't find an online compiler - [the one I know](https://shakespearelang.org/) doesn't seem to combine well with any program except the one already loaded, or maybe there's some kind of problem with the interface between the keyboard and the chair... ### Update 1: After mathmandan's comment, I edited the order of Jazz's and Buzz's scenes. It had to be done. [Answer] # [><> (Fish)](http://esolangs.org/wiki/Fish) ``` 1 > :9b)?; 0& v \ :3%?v "Fizz" r}oooo &1+& \ / < / \ :4%?v "Jazz" r}oooo &1+& \ / < / \ :5%?v "Buzz" r}oooo &1+& \ / < / \ &?v :n \ ^ +1 oa < / ``` ><> is a 2D programming language where instructions are single chars and the instruction pointer (IP) can move up, down, left or right, depending on arrows `^>v<` and mirrors `/\`. It doesn't have variables or strings so not repeating yourself is a little harder, but I think this is nice in its own way. We push `1` and start the loop. `:9b)?;` checks if the number is greater than 99 (`9b* = 911`), and if so the program halts `;`. Otherwise, put a 0 into the register and move down `v` into the wavy part. `:3%?` checks the number modulo 3. If it's nonzero, then we go down `v` a row and move left `<`. Otherwise, we skip the down arrow and push `"Fizz"`, print it (`r}oooo`) and increment the register (`&1+&`) before bouncing off the right wall mirrors to go down a row. Either way we end up moving leftward along the third row, until we bounce off the left wall mirrors. Then we repeat for `Jazz` and `Buzz`. This continues until the 7th line, which checks the register `&`'s value. If it's nonzero, then we just go down. Otherwise, we print the number itself `n` before going down. Finally, `ao` (remember, we're moving leftward now!) prints an ASCII newline and `1+` increments the number, before we go up `^` and do the loop `>` again. (Now we wait for an aesthetic Piet answer...) [Answer] # LOLCODE Elegant? Nope. Efficient? Definitely not. Beautiful? Well, you know what they say: beauty is in the eye of the beholder. ``` HAI I HAS A kitty ITZ 1 IM IN YR house UPPIN YR kitty TIL BOTH SAEM kitty AN 100 BTW, computin yr mods I HAS A d00d ITZ NOT MOD OF kitty AN 3 I HAS A doge ITZ NOT MOD OF kitty AN 4 I HAS A bro ITZ NOT MOD OF kitty AN 5 ANY OF d00d bro doge MKAY, O RLY? YA RLY d00d, O RLY? YA RLY VISIBLE "Fizz"! OIC doge, O RLY? YA RLY VISIBLE "Jazz"! BTW, wow such jazz OIC bro, O RLY? YA RLY VISIBLE "Buzz"! OIC NO WAI VISIBLE kitty! OIC VISIBLE "" IM OUTTA YR house KTHXBYE ``` --- Some explanation: LOLCODE programs begin with `HAI` and end with `KTHXBYE`. Variables are dynamically typed and are assigned using `I HAS A <variable> ITZ <value>`. Once defined, variables can also be assigned using `<variable> R <value>`. Loops in LOLCODE are named. The syntax is: ``` IM IN YR <loop> UPPIN YR <index> TIL BOTH SAEM <index> AN <end> <stuff to do> IM OUTTA YR <loop> ``` This is just Internet speak for "loop until i = end". In LOLCODE 1.2, the indexing variable needs to be initialized prior to the loop. Here the loop is named "house" because it makes reading the loop initialization sound humorous. `VISIBLE` prints to stdout. By default a newline is appended, but adding `!` suppresses the newline. Conditionals are specified as follows: ``` <condition>, O RLY? YA RLY <code to execute if condition is true> NO WAI <code to execute if condition is false> OIC ``` Conditions must either be expressions which evaluate to a boolean or boolean values. In LOLCODE, the boolean type is called `TROOF` and it has values `WIN` (true) and `FAIL` (false). Single-line comments begin with `BTW`. Not well-versed in the language of teh Internetz? Just let me know and I'll happily provide further explanation. [Answer] ## Python3 ``` lst = [('Fizz', 3), ('Jazz', 4), ('Buzz', 5), ] for i in range(1, 101): print([w for w, m in lst if i % m == 0] or [i], sep='') ``` [Answer] # Piet ![Bigger View](https://i.stack.imgur.com/GF7Ye.png)![Actual "Source"](https://i.stack.imgur.com/enF3A.png) I decided to try and play with [Piet](http://www.dangermouse.net/esoteric/piet.html) and see how pretty of a code I could make. I try not to repeat anything here, although to be honest I do have to repeat the mod calculations. However, each distinct mod (n % 3, n % 4, and n % 5) are only ever run once per iteration of code. The smaller image is the proper source, and can be uploaded and run [here](http://www.bertnase.de/npiet/npiet-execute.php). Enjoy! [Answer] # Mathematica In Mathematica you can define and overload functions for very specific parameters (not only by type, but also by arbitrary logical conditions). Let's define a few functions: ``` Fizz[n_, s___] := {n, s} Fizz[n_ /; Divisible[n, 3], s___] := {n, "Fizz" <> s} Jazz[n_, s___] := {n, s} Jazz[n_ /; Divisible[n, 4], s___] := {n, "Jazz" <> s} Buzz[n_, s___] := {n, s} Buzz[n_ /; Divisible[n, 5], s___] := {n, "Buzz" <> s} DoThe[n_] := n DoThe[_, s_] := s ``` And now the actual program is merely ``` DoThe @@@ Fizz @@@ Jazz @@@ Buzz /@ Range[100] // TableForm ``` Now while the above only grows linearly with the number of divisors, it's still not very DRY. But we can actually use variables as names in these definitions. So we can actually write a function which generates these function definitions: ``` addFunction[f_, divisor_] := ( f[n_, s___] := {n, s}; f[n_ /; Divisible[n, divisor], s___] := {n, ToString[f] <> s} ) addFunction[Fizz, 3]; addFunction[Jazz, 4]; addFunction[Buzz, 5]; DoThe[n_] := n DoThe[_, s_] := s DoThe @@@ Fizz @@@ Jazz @@@ Buzz /@ Range[100] // TableForm ``` Now all you have to do is add another `addFunction` call and add your new `*zz` to the final line. [Answer] # Haskell You guys aren't taking the DRY seriously. There are obvious patterns that can be factored out in the "Fizz Jazz Buzz" sequence. ``` import Control.Applicative -- All words end with "zz" and the numbers are in a sequence fizzes = zip [3..] $ (++ replicate 2 'z') <$> words "Fi Ja Bu" main = putStrLn . unlines $ fizzIt <$> [1..99] -- Point free style with reader monad ((->) a) to minimize -- unnecessary repetition of variable names fizzIt = nonFizzy =<< fizzy -- Show the number if no fizziness was found. Partially point free -- with respect to n. But xs is needed to prevent the error: -- "Equations for ‘nonFizzy’ have different numbers of arguments" nonFizzy "" = show nonFizzy xs = const xs -- (Ab)use the list monad for concatenating the strings fizzy i = snd =<< filter ((==0).mod i.fst) fizzes -- Could also be written as: -- > fizzy i = concat [ str \| (n,str) <- fizzes, i`mod`n==0] -- but that would be way too readable, and not pointless (ahem, point free) enough. ;) ``` This code is also easily extensible. To solve the "Fizz Jazz Buzz Tizz" problem, all you need to do is add `Ti` after the `Bu` in the string. This is much less than what is needed in any of the other solutions. [Answer] ## Excel VBA ``` Sub scopeeeeeeeeeeeeeeee() ' \|\| For u = 1 To 100 If u Mod 3 = 0 Then yell = "Fizz" If u Mod 4 = 0 Then yell = yell & "Jazz" '---------------------------------------------\| If u Mod 5 = 0 Then yell = yell & "Buzz" '---------------------------------------------\| 'made in USA If yell = "" Then yell = u Debug.Print yell '\\ yell = "" '\\ Next '\\ End Sub '\\ ``` It might sounds stupid, but it's a 2D sniper rifle! [Answer] # Java ``` void fizzy(int limit){ String[] output = new String[limit]; Arrays.fill(output,""); List<SimpleEntry<Integer,String>> tests = new ArrayList<SimpleEntry<Integer,String>>(); tests.add(newEntry(3,"Fizz")); tests.add(newEntry(4,"Jazz")); tests.add(newEntry(5,"Buzz")); for(SimpleEntry<Integer,String> test : tests) for(int i=test.getKey();i<limit;i+=test.getKey()) output[i] += test.getValue(); for(int i=1;i<limit;i++) System.out.println(output[i].length()<1 ? i : output[i]); } SimpleEntry<Integer,String> newEntry(int key, String value){ return new SimpleEntry<Integer,String>(key,value); } ``` So Java isn't really considered "beautiful" by most, but that's crazy subjective so I went by the guidelines in the question: Don't Repeat Yourself: No problem. You only need to add one line for each number. I even made a helper function so you don't have to type as much when you do (Java can be a bit verbose sometimes, if you didn't know). * Efficiency of division/modulus operations: Perfect efficiency, since there is no modulus or division at all. That's not to say that the algorithm as a whole is the most efficient (it's not), but I think it hits the bulleted points well. [Answer] # Inform 7 Inform 7 is a rule based programming language designed for interactive fiction. It is notable for being one of the most successful natural language based programming languages. See the [Inform 7 language showcase](https://codegolf.stackexchange.com/a/44800/11949) for other examples and a few bits of trivia. ``` The number printing rules are a number based rulebook. Definition: a number is fizzy if the remainder after dividing it by 3 is 0. Definition: a number is jazzy if the remainder after dividing it by 4 is 0. Definition: a number is buzzy if the remainder after dividing it by 5 is 0. A number printing rule for a fizzy number: say "Fizz"; A number printing rule for a jazzy number: say "Jazz"; A number printing rule for a buzzy number: say "Buzz"; A number printing rule for a number (called N): unless a paragraph break is pending: say N; say conditional paragraph break; To print a series of numbers from (min - a number) to (max - a number): repeat with N running from min to max: follow the number printing rules for N; ``` This code has the advantage that each of the FizzBuzz rules are completely independent: additional rules can be added at any point without needing to change the general framework. Unfortunately it's a little repetitive, especially with the definition phrases. I could define a % operator, but then it wouldn't be English. ;) This code can be [run online using Playfic](http://playfic.com/games/curiousdannii/fizzjazzbuzz). [Answer] # Python 2.7 I tried to make it poetic... I'm not very good at love poetry... ``` of = 1 my_love = 100 youre = "ever" #You are for ever in range(of, my_love) : never = "out my mind" for I,am in[#audibly (3, "Fizzing"), (4, "Jazzing"), #and (5, "Buzzing")]: if( ever % I ==0):# near you never += am #I lonely. #because youre = ever #in my mind. if( youre, never == ever,"out my mind" ): never += str(youre) #(I gave up with this line...) #then our foot- print"""s will"""( never [11:3])# part. ``` It would also be a lot better without the initial constants :P [Answer] # Dyalog APL ``` ∇FizzJazzBuzz;list;items;names items ← ⍳100 list ← ↑('Fizz' 3) ('Jazz' 4) ('Buzz' 5) names ← (,/ ↑(↓0=⍉list[;2]∘.\|items) /¨ ⊂list[;1]) ~¨ ' ' ⎕← ↑,/↑names ,¨ (∊0=⍴¨names) ⍴¨ ⊂¨⍕¨items ∇ ``` * DRY: there is no double code * Easy to change conditions: the names are taken from a list, in order, per divisor, with minimal change needed * Easy to change range: `items` can be changed to an arbitrary list of numbers * Efficient: makes use of easily parallelized list-based algorithm consisting only of side-effect free primitives. * Simple code flow: not only are there no gotos, there are no whiles or ifs either. The code is completely linear. * Secures your job: barely anybody else will be able to work on it... [Answer] # C# ``` for(int i = 1; i <= 99; i++){ string s = ""; if (i % 3 == 0) s += "Fizz"; if (i % 4 == 0) s += "Jazz"; if (i % 5 == 0) s += "Buzz"; System.Console.WriteLine(s == "" ? "" + i : s); } ``` Check mod, build string, print number if blank or string if not. No repeats. Only need to add condition & output for new requirements. [Answer] ## Java with classes The algorithm: ``` public static void main(String... args) { List<Condition> conditions = new ArrayList<Condition>(); conditions.add(new TerminatingCondition(100)); conditions.add(new ModuloCondition(3, "Fizz")); conditions.add(new ModuloCondition(4, "Jazz")); conditions.add(new ModuloCondition(5, "Buzz")); conditions.add(new EchoCondition()); while (true) { for (Condition c : conditions){ c.apply(); } } } ``` The classes: ``` interface Condition { void apply(); } static class ModuloCondition implements Condition { int modulo, count = 0; String message; ModuloCondition(int modulo, String message){ this.modulo = modulo; this.message = message; } public void apply() { count++; if (count == modulo) { out.append(message); count = 0; } } } static class TerminatingCondition implements Condition { int limit, count = 0; TerminatingCondition(int limit) { this.limit = limit; } public void apply() { count++; if (count > limit) { System.exit(0); } } } static class EchoCondition implements Condition { int count = 0, lastOutCount = 0; public void apply() { count++; out.println((lastOutCount == out.count) ? String.valueOf(count) : ""); lastOutCount = out.count; } } static class Out { int count = 0; void append(String s) { System.out.append(s); count++; } void println(String s){ append(s + System.lineSeparator()); } } static Out out = new Out(); ``` [Answer] # MATLAB / Octave Of course, writing your own loops is fun for programmers, but everybody knows how tedious keeping track of indexing really is (who hasn't written `for(j=i;j<n;i++)` in a nested loop at least once in their lives?) MATLAB has the solution. Really, this code is not the most efficient, and certainly not code-golfed, but it is by all means a good showcase of MATLAB's more interesting functions. Octave is the GNU version of MATLAB; it is however not suitable for code-golf since it is slightly stricter with variable types, which is detrimental for code-golf. EDIT: until syntax highlighting for MATLAB exists on SE, I'm posting a version with very little comments, because else it was just a [big scary block of plain text.](https://codegolf.stackexchange.com/revisions/47334/1) ``` function out = fizzjazzbuzz(n) %Initialization numberlist=1:n; fizz=cell(1,100); jazz=fizz;buzz=jazz; %Complex loops - no, wait, easy logical indexing. fizz(~mod(numberlist,3))={'Fizz'}; jazz(~mod(numberlist,4))={'Jazz'}; buzz(~mod(numberlist,5))={'Buzz'}; out=strcat(fizz,buzz,jazz); %Fill with numbers out(cellfun(@isempty,out))=num2cell(numberlist(cellfun(@isempty,out))); %Pretty output (although the default printing is perfectly acceptable) out=cellfun(@num2str,out,'UniformOutput',0); strjoin(out,sprintf('\n')); end ``` [Answer] # Python ``` from collections import defaultdict lst = [(3, 'Fizz'), (5, 'Buzz'), (4, 'Jazz')] word_list = defaultdict(list) for d, w in sorted(lst): for i in range(d, 100, d): word_list[i].append(w) for i in range(1, 100): print(''.join(word_list[i]) or i) ``` This is of course way too long. gnibbler's solution is much better. (although replacing `..., sep=''` with `''.join` would be more beautiful) But this is quite efficient in terms of division/modulus operations. [Answer] # Ruby ``` 100.times do \|n\| l = [nil, 'Fizz', 'Jazz', 'Buzz'].select.with_index{\|x, i\| x && (n % (i+2)) == 0 } puts l.empty? ? n : l '' end ``` [Answer] # Haskell ``` inp = [(3, "Fizz"), (4, "Jazz"), (5, "Buzz")] mkList (n, str) = cycle $ replicate (n-1) "" ++ [str] merge lists = (head =<< lists) : merge (map tail lists) checkFJB "" n = show n checkFJB s _ = s fjb = zipWith checkFJB (merge $ map mkList inp) [1..] print100fjb = mapM_ putStrLn $ take 100 fjb ``` Yet another solution without division or modulus. `fjb` creates an infinite list of Fizzes, Jazzes, Buzzes and/or numbers. `take` any amount you want, as seen in `print100fjb` which prints the first 100 elements. [Answer] # SQL (MySQL) ``` SELECT COALESCE(GROUP_CONCAT(FizzJazzBuzz.str ORDER BY FizzJazzBuzz.n SEPARATOR ''), I.id) FROM I LEFT JOIN ( SELECT 3 n,'Fizz' str UNION SELECT 4, 'Jazz' UNION SELECT 5, 'Buzz' ) FizzJazzBuzz ON I.id MOD FizzJazzBuzz.n = 0 GROUP BY I.id ORDER BY I.id; ``` where I is a table with one column (id INT) containing the 100 integers. I don't know an SQL flavor which can generate the table I easily, or can use VALUES as subqueries, which can make it much better and complete. [Answer] # Ruby ``` 1.upto(100) do \|i\| rules = { 3 => 'Fizz', 4 => 'Jazz', 5 => 'Buzz' } print(i) unless rules.select! { \|n,s\| i.modulo(n) > 0 or print(s) } puts end ``` [Answer] # JavaScript --- Perhaps not the most efficient way, but I think it's simple and pretty <3 ``` (function fizzBuzz(iter){ var str = ''; if(!(iter % 3)) str += 'Fizz' if(!(iter % 4)) str += 'Jazz' if(!(iter % 5)) str += 'Buzz' console.log(str \|\| iter) if(iter >= 100) return fizzBuzz(++iter) })(1) ``` --- Moar DRY and effin ugly :C ``` (function fizzBuzz(iter){ var str, fijabu = ['Fi','Ja','Bu'] ; (function isMod(_str,val){ if(!(iter % val)) _str += fijabu[val-3] + 'zz' if(val >= 5) return str = _str isMod(_str,++val) })('',3) console.log(str \|\| iter) if(iter >= 100) return fizzBuzz(++iter) })(1) ``` [Answer] # Python 2.7, 111 byte This is my first contribution. I tried to apply some Python codegolfing tricks (string interleaving, tuple index access instead of `if`). If you have any suggestion, please share them! ``` for i in range(1,101): p="" for x in 3,4,5: if not(i%x):p+="FJBiauzzzzzz"[x-3::3] print((p,i)[not len(p)]) ``` ## Output : ``` 1 2 Fizz Jazz Buzz Fizz 7 Jazz Fizz Buzz 11 FizzJazz 13 14 FizzBuzz Jazz 17 Fizz 19 JazzBuzz Fizz 22 23 FizzJazz Buzz 26 Fizz Jazz 29 FizzBuzz 31 Jazz Fizz 34 Buzz FizzJazz 37 38 Fizz JazzBuzz 41 Fizz 43 Jazz FizzBuzz 46 47 FizzJazz 49 Buzz Fizz Jazz 53 Fizz Buzz Jazz Fizz 58 59 FizzJazzBuzz 61 62 Fizz Jazz Buzz Fizz 67 Jazz Fizz Buzz 71 FizzJazz 73 74 FizzBuzz Jazz 77 Fizz 79 JazzBuzz Fizz 82 83 FizzJazz Buzz 86 Fizz Jazz 89 FizzBuzz 91 Jazz Fizz 94 Buzz FizzJazz 97 98 Fizz JazzBuzz ``` I also couldn't fully apply the DRY principle, since there are two `for` loops. There is probably a smarter way to do it! [Answer] # JavaScript DRYish ... ;) ``` (function FizzJazzBuzz(iter) { var output = ["Fi", "Ja", "Bu"]; var str = ""; output.map(function(v,i,a) { if(!(iter%(i+3))) str += output[i] + "zz"; }); console.log(str \|\| iter); if(iter < 100) FizzJazzBuzz(++iter); return; })(1); ``` [Answer] # Utterly Stupid C# Half the brief was 'DON'T REPEAT YOURSELF' so I took that as literally as I could with C# and that accidentally progressed into golfing the code. This is my first golf and I did it in C#, stupid I know but here's the result: Golfed (240 232 230 chars): ``` namespace System{using Diagnostics;using i=Int32;using s=String;class P{static void Main(){s[] z=new s[]{"Fi","Ja","Bu"};for(i a=1;a<100;a++){s l="";for(i b=3;b<6;b++)if(a%b==0)l+=z[b-3]+"zz";Trace.WriteLine((l!="")?l:a+"");}}}} ``` Ungolfed: ``` namespace System { using Diagnostics; using i = Int32; using s = String; class P { static void Main() { s[] z = new s[] { "Fi","Ja","Bu" }; for(i a = 1;a < 100;a++) { s l = ""; for(i b = 3;b < 6;b++) if(a % b == 0) l += z[b - 3] + "zz"; Trace.WriteLine((l != "") ? l : a+""); } } } } ``` The aim was to shorten any thing I had to use more than once and in general to keep the code short while producing a complete C# program. For this you will need to use VisualStudio and set the StartUp object to 'P' you will also need to look for the output in the debugging output window. There are some serious limitations here: * The code assumes that all words will end in 'zz' * The code assumes that the modulus will happen consecutively (3,4,5,6...) * The code still favours lack or repetition over true golfling, more characters are added to avoid some repeats [Answer] # Befunge-93 Not even remotely beautiful. Not easily expandable. Repeats itself. What's to like? ``` 1v < v,< >"."96p:5%\:4%\:3%#v_0"zziF$"96p>:\| >,v # $ \|:<p69"$Jazz"0_v#!\ < < $ > 1+ 25, ^ v,< > > \#v_0"zzuB$"96p>:\| @_^#`"b":.: < $< ``` It's Befunge, that's* what to like. [Answer] # Python 2 I wanted to write an answer for this in some tidy Python that would show off the features of the language, comply with the DRY principle, and be fairly readable. ``` group = range(100) rules = [('fizz', group[::3]), ('jazz', group[::4]), ('buzz', group[::5])] for number in group[1:]: labelset = '' for label, matches in rules: if number in matches: labelset += label print labelset if labelset else number ``` This little example shows slicing, the `in` operator, and the verbose but understandable ternary syntax. It does not use the modulo operator at all. It is not designed for run-time efficiency, but that was not the goal. It is designed to be short, understandable and maintainable. [Answer] # Go ## The concurrent FizzJazzBuzzer ``` package main import ( "fmt" "sort" "sync" ) var hooks map[int]string = map[int]string{ 3: "Fizz", 4: "Jazz", 5: "Buzz"} type candidate struct { num int message string } func FizzJazzBuzzer(hooks map[int]string) (chan<- int, sync.WaitGroup) { var wg sync.WaitGroup = new(sync.WaitGroup) final := func(c chan candidate) { for i := range c { if i.message == "" { fmt.Println(i.num) } else { fmt.Println(i.message) } wg.Done() } } prev := make(chan candidate) go final(prev) var keys []int = make([]int, 0) for k := range hooks { keys = append(keys, k) } sort.Sort(sort.Reverse(sort.IntSlice(keys))) for _, mod := range keys { c := make(chan candidate) s := hooks[mod] go (func(in chan candidate, next chan candidate, mod int, s string) { for i := range in { if i.num%mod == 0 { i.message += s } next <- i } })(c, prev, mod, s) prev = c } in := make(chan int) go (func(in <-chan int) { for i := range in { prev <- candidate{i, ""} } })(in) return in, wg } func main() { in, wg := FizzJazzBuzzer(hooks) for i := 1; i < 20; i++ { wg.Add(1) in <- i } wg.Wait() } ``` Try it here: <http://play.golang.org/p/lxaZF_oOax> It only uses one modulus per number checked and can be arbitrarily be extended to any number of, well... numbers. You only have to make changes 3 different places to extend this, in the `hooks` map, the `FizzJazzBuzzer` function name and, of course, the call to the `FizzJazzBuzzer` function. [Answer] ## R This creates a function which allows a user to specify pairs of words and divisors (and optionally a maximum number, with 100 as the default). The function creates a vector from 1 to the maximum number, then replaces any numbers at "fizzbuzz" positions with "", and finally pastes each word at its desired position. The function orders the list from lowest to highest number so that the lowest number will always be the first part of the "fizzbuzz". The positions are calculated using `seq` to create a vector starting at a given number and increasing in increments of that number until the maximum desired number is reached. ``` fizzbuzzer = function(max.num=100, ...){ input = list(...) input = input[order(unlist(input))] #reorder input list by number words = names(input) #vector containing the result output = seq_len(max.num) #remove numbers at positions to contain a "fizzbuzz" sapply(input, function(x) output[seq(x, max.num, x)] <<- "") #add words at required points sapply(seq_len(length(input)), function(i) output[seq(input[[i]], max.num, input[[i]])] <<- paste0(output[seq(input[[i]], max.num, input[[i]])], words[i])) return(output) } ``` I don't think it's very beautiful, but it's easy to re-use with different parameters. usage examples: ``` fizzbuzzer(fizz=3, buzz=5) fizzbuzzer(fizz=3, buzz=5, jazz=4) fizzbuzzer(max.num=10000, golf=10, stack=100, code=1, exchange=1000) ``` The output of `fizzbuzzer(fizz=3, buzz=5)` is: ``` [1] "1" "2" "fizz" "4" "buzz" "fizz" [7] "7" "8" "fizz" "buzz" "11" "fizz" [13] "13" "14" "fizzbuzz" "16" "17" "fizz" [19] "19" "buzz" "fizz" "22" "23" "fizz" [25] "buzz" "26" "fizz" "28" "29" "fizzbuzz" [31] "31" "32" "fizz" "34" "buzz" "fizz" [37] "37" "38" "fizz" "buzz" "41" "fizz" [43] "43" "44" "fizzbuzz" "46" "47" "fizz" [49] "49" "buzz" "fizz" "52" "53" "fizz" [55] "buzz" "56" "fizz" "58" "59" "fizzbuzz" [61] "61" "62" "fizz" "64" "buzz" "fizz" [67] "67" "68" "fizz" "buzz" "71" "fizz" [73] "73" "74" "fizzbuzz" "76" "77" "fizz" [79] "79" "buzz" "fizz" "82" "83" "fizz" [85] "buzz" "86" "fizz" "88" "89" "fizzbuzz" [91] "91" "92" "fizz" "94" "buzz" "fizz" [97] "97" "98" "fizz" "buzz" ``` (numbers in square brackets are the indices of the vector the function outputs) [Answer] ## Haskell No modular arithmetic is used, except in computing the least common multiple to avoid repeating unnecessary work. The string concatenations only need to be done 60 times, no matter what we set the upper limit to. ``` -- Don't repeat `transpose` from `Data.List` import Data.List (transpose) -- The desired problem lst = [(3, "Fizz"), (4, "Jazz"), (5, "Buzz")] -- Map a function over both sides of a tuple. -- We could also get this from importing Bifunctor (bimap), bit it's not in the core libraries bimap f g (x, y) = (f x, g y) -- Make infinite lists with the word occuring only once every n items, starting with the first fizzify = map (cycle . uncurry take . bimap id (:repeat "")) -- Reorganize the lists so there's a single infinite list, smash the words together, and drop the first set. fjb = tail . map concat . transpose . fizzify -- The following two functions avoid repeating work building the lists -- Computes the least common multiple of a list of numbers lcms = foldr lcm 1 -- fjbLcm is just a more efficient version of fjb; they can be used interchangably fjbLcm lst = cycle . take (lcms . map fst $ lst) . fjb $ lst -- show the number if there aren't any words result = zipWith (\x y -> if null x then show y else x) (fjbLcm lst) [1..100] main = print result ``` Replacing `fjbLcm` with `fjb` does exactly the same thing, with no arithmetic used except in `[1..100]` and `take`. [Answer] ## Python2 Update: New version doesn't use any mod or division operations. ``` word_dict = {3: 'Fizz', 4: 'Jazz', 5: 'Buzz'} def fizz_jazz_buzz(n, d): counters = {k: k for k in d} for i in xrange(1, n + 1): u = '' for k in d: if counters[k] == i: u += d[k] counters[k] += k print u or i fizz_jazz_buzz(100, word_dict) ``` If you want to add another word to the test, just throw the key/value pair into the word\_dict dictionary: ``` word_dict[7] = 'Razz' fizz_jazz_buzz(100, word_dict) ``` If you want to get rid of a word, just delete it (using `del`) or alternatively set it to `''`. ``` del word_dict[3] fizz_jazz_buzz(100, word_dict) ``` See also the Python answers of [Gnibbler](https://codegolf.stackexchange.com/a/47331/36885) and [Jakube](https://codegolf.stackexchange.com/a/47335/36885), which were posted before mine. ]
[Question] [ Input: Two decimal integers. These can be given to the code in standard input, as arguments to the program or function, or as a list. Output: Their product, as a decimal integer. For example, the input `5 16` would lead to the output `80`. Restrictions: No standard loopholes please. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), answer in lowest amount of bytes wins. Notes: Layout stolen from my earlier challenge, [Add two numbers](https://codegolf.stackexchange.com/q/84260/46271). Test cases: ``` 1 2 -> 2 4 5 -> 20 7 9 -> 63 -2 8 -> -16 8 -9 -> -72 -8 -9 -> 72 0 8 -> 0 0 -8 -> 0 8 0 -> 0 -8 0 -> 0 0 0 -> 0 ``` Or as CSV: ``` a,b,c 1,2,2 4,5,20 7,9,63 -2,8,-16 8,-9,-72 -8,-9,72 0,8,0 0,-8,0 8,0,0 -8,0,0 0,0,0 ``` # Leaderboard ``` var QUESTION_ID=106182,OVERRIDE_USER=8478;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+)(?=[^\n\d<>](?:<(?:s>[^\n<>]<\/s>\|[^\n<>]+>)[^\n\d<>])<\/h\d>)/,OVERRIDE_REG=/^Override\sheader:\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> ``` [Answer] # Brachylog V1, 05AB1E, J, K, Underload, MATL, Forth, PigeonScript, Stacked, Implicit, Jolf, Clojure, Braingolf, 8th, Common Lisp, Julia, Pyt, Appleseed, Stax, Reality, dc, Vyxal, Keg, Swift, Fig\, Chocolate, ><>, Thunno\: 1 byte ``` ``` You may edit this answer to add other languages for which `` is a valid answer. \Actually \$\log\_{256}(96)\approx\$ 0.823 bytes in Fig and Thunno [Answer] # C (GCC), 13 bytes Doesn't work on all implementations, but that's OK. ``` f(a,b){a=b;} ``` [Try it on TIO!](https://tio.run/nexus/c-gcc#@5@mkaiTpFmdqGWbZF37PzcxM09Ds7qgKDOvJE1DSTVFSSdNw1zHUlMTKAkA "C (gcc) – TIO Nexus") [Answer] # [Beatnik](https://esolangs.org/wiki/Beatnik), 888 bytes ``` k I j k ZZZZX z xw k C vp yQ KD xw z j k ZZZZX z j k ZZZD z xw bZ ZX k XX z qs xw vp xw xw vp xw vp vp vp k I Xj ZZD hd xw yQ K k ZZZZX xo exx qs yQ XA xw xw xw xw z xw bZ K xw xw k I j k ZZZZX z xw k C vp yQ XA hd k I z j k ZZZZX z j xw k A vp bZ ZX k ZZZZX z qs xw vp xw xw vp xw vp vp vp k I Xj ZZD hd xw yQ K k ZZZZX xo exx qs yQ F k ZZZZK xo vp xw xw z qs xw bZ X xw k I z xw Xj K qs xw bZ KA vp qs xw Xj C hd qs z xw xw xw xw z qs xw xw xw xw z qs k I qs k I z xw Xj ZC qs bZ ZZZX qs xw yQ C hd xw k I vp qs k I qs xw Xj ZZC hd hd z Kz ZZD k I z xw xw xw xw z qs k I qs k I Xj ZZZZF z xw xw z qs xw bZ X xw k I z xw Xj K qs xw bZ KA vp qs xw Xj C hd z qs xw xw xw z qs xw bZ X xw k I z xw Xj K qs xw bZ KA vp qs xw Xj C hd z vp xw xw z qs xw xw z qs k I qs xw bZ ZZX k I z qs k I vp xw k ZA z yQ ZA hd qs k I vp qs k I Xj ZZKD qs xw Xj ZZK hd qs xw Xj ZZZZ hd k ZZZZKD vp xo xw Xj K ``` [Try it online!](https://tio.run/##tVdtU9s4EP4c/4qFfohDHIqB9noEc5fjZYYJQ3uUm2HCMYxiy7FIYqmWQoAOv51bSbaJc0kHrhxkFGt3tc@zq5W16ROZPIVEwV6fEpWy4XoIu7v1w9ODuvN@Df447JyfHneBpYpmIqM4wphEFPr3sE8UUTxlIXzhmeBMUtgdZGRCf@chJWmfSLrOs8GeAwAERjwdgGJjCmTA1@E8YRISIiHlCvqUpqCoVDTKNfgRk/4IfUd8TFi6DmvvHecdS8PRBNF3pYoYX0/2KqKMpYOqLFT3gmqREyYkgzUS3ZI0pK6deTqsRjvXYXAZpmBOhyPIMCP9/qhYhtJJKtkgpREYieDCveUsQoX@QuYycSsmBYgeSIhJHFBVLDEQOkZXP5BsEHo52Wxwe3nVgO9O7ej45BDW4rZTsyrhQTiOLv0N/LtCqV7Jgg3vxhsGvic9hW5rLHa1t93NBmBskywFv22kbhzEXNDUNQj@lbearTYaQXD618lJabuJttOEYdTuTYB0QzduNFaCw89HhlFN47Or4AbNaqzZxK9HpxaHIy4pWmqm1qAO9bbVF4J4XsDnBXfzgvs6TkSAUx2YpTW0POSUqTBxyz0SDSuvhVh/8GEHsIq/4IZASu8UTHkW6VJCPforykF4vmasZXrrZn21l5r2sVqG7RLpo0XiAtLJuI/HhKQRREyGBBGZKkGxVl7u9JfSqZry3LH0gEQRqISOPVNquGNyMnpG0CEYmKYZX472yaAdp2KinivVxGFgbsloQisolXJ@BdCvZVjWp4bgE1XFLYGUlrmvjMXfKDE2LQrmTU76SnuHmGUSx4yPQdKQp9HCTKpgdrfKtLbUK2j4i2hMicj3r0yunkKfhMOF4PJfTFSlYF9BaLOa@zxwLFA1ZSFdHrpaOHkB4NY8oBwyASShJIK06ZsjiS/8OK8FfPM/0Iz/6JCqYOaEWhG@1VZshcDsioInHSGTl5Ddfi3ZtK7@I9@3oPthIV1TRun/kNjiikSmTf@1XD@@iusb5PWn2No371fFzUkFkXFsbcYFm2GwMb8sojHBd4dZ1sGmJsFXmI6qNaLpQCU6/QSbnRY6XBrSo75EnVp@AyPEo7OoARHmhjN3vleoLq@C7763hf@bnu9t47iN35@8D56W@nbcMA@@MdhGJZpsPCJwzDMX24f2mljBUTSb9gplzYBJMhIJcRHztxJK8RGf0kwLW3VSv9oxycDUMykFwXjW9CVcpOaxDIiZgBZ1YsK0W6CeA5thxXaVbgcsJ2H6grwFWKkAVlQLNM9ExAyRattXIYI7ecoV3cEKwN2LJ2moGE@BSDkZU4nGelN1dfTpgKUpdp/AY9xlve1Y3li7rmj5Dc2JjUZoBcgN21xNzBRBEalotZbFuygaY704BUaFgdqIK@FWe1ap8OBdbtn@0dSY0DVd6bBHrG965yXdruZXVYW2v5QibxEDi9JqSaG71Jqd4sQen5xemFPG9l3F7upR57xzAodnZ5/PdvDAwJhnNL86AbNvfPydruoDQ@@Ycrca7bkjs6QJh9DQKkg0m1dBaOzfsRhPLxx8/rp/1vni6N8952ZXscz1FuPGaCWij@7nfodg72B/hyzr7zVimZvQNNKJuVcxT2EQ@FsNmJU@p0Tz0m@rH3guWnWzHFukRhvMqjRisYO/4JxBGMLzz7oWLyaOuc9aKPJhD0KuI9m9vsYl19dPQzh2bmAIPfy7gAfnboqTfbgVcP8ndA8A5w8wa5A/H6AYdf0e9C6cIVygCr5JLcKlOJYPONoPIsHFDeilSaRxNEDp@I4Dvbtz0AWKLzq5C/spkLqOnf@QM65NIgM2z9uYdbRZwTrXvR3xo1zcRbFzK5yCvwVA2Iucv40JvXadUtc13OwUNfsaDWcPc7n4Jp15gfGYfxWOe/t6sY5Us7RekaH2io@ONrVodq2Tr@oZA/w8QPdBx@yUTpdCmnW93pHz8PMB50vfwlEl/7OPzxGb9FzkbvNo7DLcxw7KMGM9U1ClshJ098ApUXHmWMNi3utpInlFHJiy4gX5p/wAOuvv82NqTubTNrQ2/wE "Bash – Try It Online") I'm using the C interpreter because the Python interpreter on TIO annoyingly executes the address if the condition for jumping backward isn't met. An easy workaround for the Python interpreter is to pad some nops to make the address nop. I believe neither is correct: ``` C Python My interpretation IP after skiping N words IP+N+1 IP+N+2 IP+N+2 IP after skiping back N words IP-N IP-N+1 IP-N+2 IP after not skiping N words IP+2 IP+2 IP+2 IP after not skiping back N words IP+2 IP+1 IP+2 ``` Input should be two integers separated by a space, without trailing newlines. This answer works in theory for all integers, if each cell can store an arbitrarily large value, not limited to 0 - 255. But it overflows if \|A\|+\|B\| > 22. And it runs very slowly if \|A\|+\|B\| > 6. So there is not many cases you can actually test and an if-else solution for those cases might be even shorter. The idea is to compute the triangular numbers T(N) = N(N+1)/2 by decrementing the value to 0 and summing up all the intermediate values. Then we can get the answer A\B = T(A+B) - T(A) - T(B). But it is tricky to compute all the 3 values. It does this by firstly computing T(A+B) - A, leaving a copy of A in the stack to add back later, and using up the input B. Then recursively find the greatest triangular number smaller than that, which is T(A+B-1) except for the zero special cases. We can get back B = T(A+B) - A - T(A+B-1) and compute T(B) from there. A number N is a triangular number iff it equals to the greatest triangular number smaller than N, plus the number of non-negative triangular numbers smaller than N. This runs in O(2^(T(A+B)-A)) and is the slowest part in the program. ``` k I Push 1 j k ZZZZKAAA z Input and decrement by 48. xw k AAA vp yQ (input_a_loop) If the character was '-': xw z j k ZZZZKAAA z Replace with 0 and input another. input_a_loop: j k ZZZAA z xw bZ (input_a_end) Input and break if it is a space. k ZKA z qs xw vp xw xw vp xw vp vp vp Otherwise multiply the previous value by 10 and add. k I Xj (input_a_loop) Continue the loop. input_a_end: hd Discard the space. xw yQ (check_sign) k ZZZZKAAA xo exx If A=0, print 0 and exit. Stack: ?, A_is_positive, A check_sign: qs yQ (check_sign_else) If A is positive... or not, xw xw xw xw z xw bZ (check_sign_end) in either cases, push 2 copies check_sign_else: xw xw k I of A and the negated flag back check_sign_end: as a constant. Stack: A, A, A, A_is_negative j k ZZZZKAAA z Similar for B. xw k AAA vp yQ (input_b_loop) If the character was '-': hd k I z j k ZZZZKAAA z Decrement the flag and input another. input_b_loop: j xw k A vp bZ (input_b_end) EOF is checked instead of a space. k ZZZZKAAA z qs xw vp xw xw vp xw vp vp vp k I Xj (input_b_loop) input_b_end: hd xw yQ (output_sign) k ZZZZKAAA xo exx If B=0, print 0 and exit. Stack: A, A, A, AB_is_negative, B output_sign: qs yQ (output_sign_end) k ZZZZK xo If negative, output '-'. output_sign_end: vp Add. Stack: A, A, A+B xw xw z qs Insert a 0. Stack: A, A, 0, A+B. xw bZ { xw k I z xw Xj } Copy and decrement while nonzero. Stack: A, A, 0, A+B, A+B-1, ..., 0 qs xw bZ { vp qs xw Xj } hd Add while the second value in the stack is nonzero. Stack: A, A, T(A+B) qs z xw xw xw xw z qs Stack: A, C0=T(A+B)-A, C0, F0=0, C0 expand_loop: xw xw xw xw z qs k I qs Stack: A, C0, C0, F0=0, ..., [P=C, P, S=0, F=1], C dec_expand: k I z xw Xj (expand_loop) Decrement and continue if nonzero. Stack: [P=1, P, S, F], C=0 The last number 0 is assumed to be a triangular number. test: qs bZ (extract_end) If F=0, break. qs xw yQ (test_not_first) hd xw If S=0, it's the first triangular number below previous C. Set S=C. test_not_first: k I vp qs k I qs S+=1 and restore F=1. xw Xj (dec_expand) If C!=0, recursively expand from C-1. hd hd z Kz (test) If S=P, P is a triangular number, return to the previous level. k I z xw xw xw xw z qs k I qs Otherwise, decrement P and try again. k I Xj (dec_expand) extract_end: Stack: A, C0, C0, T(A+B-1) z Subtract and get B. xw xw z qs xw bZ { xw k I z xw Xj } Computes T(B). qs xw bZ { vp qs xw Xj } hd Stack: A, C0, T(B) z qs xw Stack: C0-T(B), A, A xw xw z qs xw bZ { xw k I z xw Xj } Computes T(A). qs xw bZ { vp qs xw Xj } hd z vp Get AB=(C0-T(B))+(A-T(A)) xw xw z qs Stack: 0, X=AB divide: xw xw z qs Stack: 0, ..., Y=0, X subtract: k I qs Stack: 0, ..., Y, Z=1, X xw bZ { While X!=0: k I z qs k I vp X-=1, Z+=1. xw k ZA z yQ (not_ten) But if Z=11: hd qs k I vp qs k I Xj (subtract) Y+=1, reset Z and restart the loop. not_ten: qs xw Xj } hd qs xw Xj (divide) Put Z under Y and make Y the new X, continue the loop if X!=0. hd Discard X. print_loop: k ZZZZKAA vp xo xw Xj (print_loop) Add each cell by 47 and print. ``` [Answer] # [Scratch](https://scratch.mit.edu/), 1 byte [![enter image description here](https://i.stack.imgur.com/dNzEs.png)](https://i.stack.imgur.com/dNzEs.png) Usage: Place numbers in both sides of `` sign Note: Since Scratch is a visual language I could not figure out how many bytes it consumes until @mbomb007 noted me about a method for [counting scratch bytes](https://codegolf.meta.stackexchange.com/a/5013/34718) [Answer] # Mathematica, 4 bytes ``` 1##& ``` Example usage: `1##&[7,9]` returns `63`. Indeed, this same function multplies any number of arguments of any type together. As Mathematica codegolfers know, this works because `##` refers to the entire sequence of arguments to a function, and concatenation in Mathematica (often) represents multiplication; so `1##` refers to (1 times) the product of all the arguments of the function. The `&` is just short for the `Function` command that defines a pure (unnamed) function. Inside other code, the common symbol `` does act as multiplication. So does a space, so that `7 9` is interpreted as `79` (indeed, the current REPL version of Mathematica actually displays such spaces as multiplication signs!). Even better, though, if Mathematica can tell where one token starts and another ends, then no bytes at all are needed for a multiplication operator: `5y` is automatically interpreted as `5y`, and `3.14Log[9]` as `3.14Log[9]`. [Answer] # [Retina](https://github.com/m-ender/retina), 38 37 31 bytes Completely new approach, the old one is below. ``` M!`- \)`-¶- . $_ _ $'$_ _ ``` [Try it online!](https://tio.run/nexus/retina#U9VwT@AC4v@@igm6XFoxmgm6h7bpcnHpaSlwqWjFc8VzqaiD6f//DRWMuEwUTLnMFSy5dI0ULLgsFHSBLDBpAOQaKOiCxAxAQgZAngEA "Retina – TIO Nexus") ### Explanation First, we deal with the sign: ``` M!`- ``` matches all `-` in the string and returns them separated by newlines ``` \)`-¶- ``` (with a following empty line) `\)` means the result of this and the previous stages should be printed without a newline, and then the string reverted to what it was before (the input string). The remaining part removes two `-` separated by a newline. Then we convert the first number to unary: ``` .* $_ ``` (there's a space at the end of the first line). We use `_` as our unary digit in this case, because the standard digit `1` can be present in the second number, and this would conflict later. Now we get to the actual multiplication: ``` _ $'$_ ``` Each `_` is replaced by the unary representation of everything following it (still using `_` as the unary digit). Since conversion to unary ignores non-digit characters, this will repeat the unary representation of the second number for "first number" times. The second number will remain in decimal representation at the end of the string. In the end, with a single `_` we return the number of `_` in the string, which will be the result of the multiplication. --- Previous answer: (warning: outputs an empty string when it should output `0`) ## [Retina](https://github.com/m-ender/retina), 45 42 41 bytes Let's play a game! Multiply relative numbers with a language which has no arithmetic operators and limited support only for natural numbers... Sounds funny :) ``` O^`^\|- -- \d+ $* 1(?=1* (1))? $1 1+ $.& ``` ### Explanation The first three lines deal with the sign: ``` O^`^\|- ``` This sorts `O` and then reverses `^` all strings matching the regex `^\|-`. In practice this matches the empty string at the start, and the eventual minus sign before the second number, and reorders them placing the empty string in the place of the minus. After this, all `-` are at the beginning of the string, and a pair of them can be removed easily with the next two lines. After that, we use a builtin to convert numbers to unary representation, and then comes the actual multiplication: ``` 1(?=1 (1))? $1 ``` We match any `1`, and substitute each of them with all the `1` after a following space. Each digit of the first number will be replaced by the full second number, while each digit of the second number will be replaced by the empty string. The last part is again a builtin to convert back from unary to decimal. [Try it online!](https://tio.run/nexus/retina#U9VwT/jvH5cQV6PLpavLxRWTos2losVlqGFva6iloGGopalpz6ViyGUIFNZT@//fUMGIy0TBlMtcwZJL10jBgstCQRfIApEA "Retina – TIO Nexus") [Answer] # [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 56 bytes ``` ([({}<([({})<>])<>>)<>]){({}[()]<(({})<({}{})>)>)<>}{}{} ``` This must be run as a full program as it is not stack clean and the inputs must be the only elements in either stack. [Try it online!](https://tio.run/nexus/brain-flak#@68RrVFdawMmNW3sYoHYDkxXAwWiNTRjbTTAMkACSNlpgiRrQez//3UtFHQtAQ "Brain-Flak – TIO Nexus") --- Explanation:* (call the inputs x and y) Part 1: ``` ([({}<([({})<>])<>>)<>]) ([ ]) # Push negative x on top of: ([ ]) # negative y. After... ({}< >) # pushing x and... ({}) # y... <> <> <> # on the other stack (and come back) ``` At this point we have [x,y] on one stack and [-x,-y] on the other. Part 2: ``` {({}[()]<(({})<({}{})>)>)<>}{}{} { } # Loop until x (or -x) is 0 ({}[()]< >) # Decrement x (({})< >) # Hold onto y ({}{}) # Add y and the number under it (initially 0) <> # Switch stacks {}{} # Pop x and y leaving the sum ``` [Answer] ## JavaScript (ES6), 9 bytes ES6 has a dedicated function for 32-bit integers, faster than the more generic `` operator. ``` Math.imul ``` Incidentally, this is just as long as: ``` a=>b=>ab ``` [Answer] # [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~56~~ ~~54~~ 52 bytes 2 bytes saved thanks to a mistake caught by Nitrodon ``` ({}(<()>)<>)({<([{}({}())])><>([{}]([{}]))<>}<{}{}>) ``` [Try it online!](https://tio.run/##SypKzMzTTctJzP7/X6O6VsNGQ9NO08ZOU6PaRiMayAciTc1YTTsbOxA3FkxoAhXU2lTXVtfaaf7/b2ikoGto9F83BQA "Brain-Flak – Try It Online") # Stack clean version, ~~62~~ 60 bytes ``` ({}(<()>)(<>))({<([{}({}())])><>([{}]([{}]))<>}<{}{}<>{}{}>) ``` [Try it online!](https://tio.run/##HYixCoAwDAV/xTFvyNDOj/yIdKiIIIqDa8i3x1Y4Du62t5@PHne/MsVDKDAIDRCnrOMMgAajzWy/AFrQw4M2bcgsddFSU/cP "Brain-Flak – Try It Online") ## Explanation This explanation is more of an explanation of the algorithm involved and leaves out any actual code. It assumes that you know how to read Brain-Flak proficiently. If you need help understanding either the code or the algorithm I would be happy to edit or respond if you leave a comment. This is a little bit of a strange one and uses some weird math that just barely works out. The first thing I did was to make a loop that would always terminate in O(n) steps. The normal way to do this is to put n and -n on opposite stacks and add one to each until one hits zero, however I did it in a slightly stranger way. In my method I put a counter underneath the input and each step I increment the counter add it to n and flip the sign of n. Let's walk through an example. Say n = 7 ``` 7 -8 6 -9 5 -10 4 -11 3 -12 2 -13 1 -14 0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ``` I won't prove it here but this will always terminate for any input and will do so in about 2n steps. In fact it will terminate in 2n steps if n is positive and 2n-1 steps if n is negative. You can test that out [here](https://tio.run/##SypKzMzTTctJzP7/X6O6VrNaI7q6FsjQ0NSM1aytrv3/X9ccAA "Brain-Flak – Try It Online"). Now we have about 2n steps in our loop how do we multiply by n? Well here have some math magic. Here's what we do: We make an accumulator, each step of the process we add the second input (m) to the accumulator and flip the sign of both of them, we then push the total over all the loops that occur, this is the product. Why on earth is that the case? Well lets walk through an example and hopefully it will become clear. In this example we are multiplying 5 by 3, I will show only the important values ``` total -> 0 -5 5 -10 10 -15 15 accumulator -> 0 -5 10 -15 20 -25 30 m -> 5 -5 5 -5 5 -5 5 ``` Hopefully the mechanism is apparent here. We are stepping through all the multiples of m in order of their absolute values. You will then notice that the 2nth term is always *m \ n and the term before always -m \* n*. This makes it so that our looping perfectly lines up with the results we want. A bit of a happy coincidence ;) [Answer] # [Dyalog APL](http://goo.gl/9KrKoM), 1 [byte](http://meta.codegolf.stackexchange.com/a/9429/43319) [`×` takes one number on the left, and one on the right](http://tryapl.org/?a=8%20%D7%20%AF9&run) `×` ... or even multiple numbers [on the left](http://tryapl.org/?a=%AF8%20%D7%202%205%209%208%20%AF9%209&run) or [on the right](http://tryapl.org/?a=1%204%207%20%AF2%208%20%AF8%20%D7%209&run) or [on both sides](http://tryapl.org/?a=1%204%207%20%AF2%208%20%AF8%20%D7%202%205%209%208%20%AF9%209&run) [`×/` multiplies all numbers in a list](http://tryapl.org/?a=%D7/%208%20%AF9&run) [`×/¨` multiplies the pairs in a given list](http://tryapl.org/?a=%u22A2A%u2190%281%202%29%284%205%29%287%209%29%28%AF2%208%29%288%20%AF9%29%28%AF8%209%29%20%u22C4%20%D7/%A8%20A&run) [`×/∊` mulitplies all numbers in an array](http://tryapl.org/?a=%u22A2A%u2190%281%202%29%284%205%29%287%209%29%28%AF2%208%29%288%20%AF9%29%28%AF8%209%29%20%u22C4%20%D7/%u220A%20A&run) This applies to all arithmetic functions, arrays of all sizes and ranks, and numbers of all datatypes. [Answer] # R, 3 bytes ``` '' ``` This is a function which takes exactly two arguments. Run as `''(a,b)`. See also `prod` which does the same thing but can take an arbitrary number of arguments. [Answer] # [ArnoldC](https://lhartikk.github.io/ArnoldC/), 152 bytes ``` HEY CHRISTMAS TREE c YOU SET US UP 0 GET TO THE CHOPPER c HERE IS MY INVITATION a YOU'RE FIRED b ENOUGH TALK TALK TO THE HAND c YOU HAVE BEEN TERMINATED ``` [Try it online!](https://tio.run/nexus/arnoldc#bc4xDsIwDAXQPafw1qkSQy8Q6Ke2IEmVOEUdS4XEBKdnLkHAUnWxLPnpf4tWiRKHi4qDYYx04ChJnU2kEaDJjCFTglJOlHuqmy11Xalm2UDzCu1MV3YNpIxiQ98jFsSIIEnkRhI/iFqV4L9/VOVylIi2FMKH3DGpPZ/MZ/yD2Pr2V8V2AO0BT4roxFtFuyyvx7Oep/l@ewM "ArnoldC – TIO Nexus") [Answer] ## [Hexagony](https://github.com/m-ender/hexagony), 9 bytes ``` ?{?/!@'/ ``` [Try it online!](https://tio.run/nexus/hexagony#@29fba@vpeigrv//v4WCriUA "Hexagony – TIO Nexus") This is actually fairly straightforward. Here is the unfolded version: ``` ? { ? / * ! @ ' / . . . . . . . . . . ``` The `/` just redirect the control flow to the second line to save bytes on the third. That reduces the code to this linear program: ``` ?{?'!@ ``` This linear code on its own would actually be a valid solution if the input was limited to strictly positive numbers, but due to the possibility of non-positive results, this isn't guaranteed to terminate. The program makes use of three memory edges in a Y-shape: ``` A B \ / \| C ``` The memory pointer starts on edge `A` pointing towards the centre. ``` ? Read first input into edge A. { Move forward to edge B. ? Read second input into edge B. ' Move backward to edge C. Multiply edges A and B and store the result in C. ! Print the result. @ Terminate the program. ``` I ran a brute force search for 7-byte solutions (i.e. those that fit into side-length 2), and if I didn't make a mistake (or there's a busy-beaver-y solution that takes a long time to complete, which I doubt) then a 7-byte solution doesn't exist. There might be an 8-byte solution (e.g. by reusing the `?` or using only one redirection command instead of two `/`), but that's beyond what my brute force search can do, and I haven't found one by hand yet. [Answer] # [Piet](http://www.dangermouse.net/esoteric/piet.html), [16 bytes](http://meta.codegolf.stackexchange.com/questions/10991/how-to-determine-the-length-of-a-piet-program) ``` 5bpiaibpikibptai ``` [Online interpreter available here.](http://zobier.net/piet/) ## Explanation To run, paste the code above in the text box on the right side of the linked page. Below is a graphical representation of this code with codel size 31. The grid is for readability and may interfere with traditional Piet interpreters. The code runs linearly from left to right, going along the top of the image until the first green block, where program flow moves to the middle row of codels. The white lone white codel is necessary for program flow. It could be replaced with a codel of any color other than green or dark blue, but I have chosen white for readability. [![Code Visualization](https://i.stack.imgur.com/IWm75.png)](https://i.stack.imgur.com/IWm75.png) ``` Instruction Δ Hue Δ Lightness Stack ----------- ----- ----------- ----- In (Number) 4 2 m In (Number) 4 2 n, m Multiply 1 2 mn Out (Number) 5 1 [Empty] [Exit] [N/A] [N/A] [Empty] ``` If you think that text is not the best way to represent a Piet program or have an issue with the byte size of Piet programs in general, please let your opinion be known in [the discussion on meta](http://meta.codegolf.stackexchange.com/questions/10991/how-to-determine-the-length-of-a-piet-program). [Answer] # [BitCycle](https://github.com/dloscutoff/esolangs/tree/master/BitCycle) `-U`, 68 bytes ``` > > v ?+ > + Bv ?^ v ~ \ v<CB~\v Cv ^ <\/ ^ <@=! < 0A^ ``` [Try it online!](https://tio.run/##FYs7CoAwEAX7PcWzlqCVNvEXz2AXUhgsBFHBsGCTo7smzcAwzLoH//pjEwF6IIMJQ5mlJMMYHBiRYAHWs4k25ZkBB2hbkYMeuyJ9murJiYhqRTXfdYf9Oh9Ryw8) Multiplying two numbers is not a trivial problem in BitCycle, especially when signs need to be handled! This is my second attempt; the first one (essentially same algorithm, different layout) was 81 bytes, so it's quite possible this one could be shortened too. The program takes the two numbers as command-line arguments and outputs to stdout. The `-U` flag is to convert the decimal numbers to [signed unary](https://codegolf.stackexchange.com/q/150775/16766), since BitCycle knows only of 0's and 1's. ## Explanation This explanation assumes you understand the basics of BitCycle (see [Esolangs](https://esolangs.org/wiki/BitCycle) or the GitHub readme). I'll base my explanation on this ungolfed version, seen here computing `-2` times `3`: [![Signed multiplication in BitCycle](https://i.stack.imgur.com/xS1ZA.gif)](https://i.stack.imgur.com/xS1ZA.gif) ### Overview Signed unary numbers consist of the sign (`0` for nonpositive, empty for positive) followed by the magnitude (a number of `1`s equal to the number's absolute value). To multiply two of them, we need to XOR the signs (output a `0` if exactly one of them is `0`, or nothing if both or neither are) and then multiply the magnitudes (and output that many `1`s). We'll achieve the multiplication by repeated addition. ### Sign bits Starting from the two sources `?`, we split off the signs from the magnitudes using `+`. `0`s (sign bits) turn left and are directed along the top row, while `1`s (magnitudes) turn right and end up in the two `B` collectors. The section that handles the signs looks like this: ``` v \ v > \ / ! < ``` If both numbers are nonpositive, two `0` bits come in from the top `v`. The first one reflects off the top `\`, is sent southward, and reflects off the `/`. Meanwhile, the second bit passes through the deactivated top `\` and reflects off the bottom `\`. The two bits pass each other, go straight through the now-deactivated splitters on the bottom row, and go off the playfield. If only one of the numbers is nonpositive, one `0` comes in from the top. It bounces around all three splitters and ends up going northward again, until it hits the `v` and is once more sent south. This time, it passes through the deactivated splitters and reaches the `<`, which sends it into the sink `!`. ### Loops to store the magnitudes The magnitude of the first number goes into the `B` collector in this section: ``` B v \ C v ^ < 0 A ^ ``` Before the `B` collector opens, the `A` collector releases the single `0` that was placed in it, which then goes onto the end of the queue in `B`. We'll use it as a flag value to terminate the loop when all the `1` bits in `B` are gone. Each time the `B` collectors open, the `\` splitter peels off the first bit from the queue and sends it to the processing logic in the middle. The rest of the bits go into `C`, and when the `C` collectors open, they are sent back into `B`. The magnitude of the second number goes into the `B` collector in this section: ``` v ~ C B ~ < ``` When the `B` collectors open, the bits go into the bottom dupneg `~`. The original `1` bits turn right and are sent west into the processing logic in the middle. The negated copies (`0`s) turn left and immediately hit another dupneg. Here the `0`s turn right and go off the playfield, while the (now doubly) negated `1`s turn left and are sent into `C`. When `C` opens, they go back into `B`. ### Repeated addition The central processing logic is this part: ``` v v @ = ! ``` Bits from both loops (one from the western side, and everything from the eastern side) are sent south into the switch `=`. The timing has to be set up so that the bit from the western loop gets there first. If it is a `1`, the switch changes to `}`, sending the following bits eastward into the sink `!` to be output. Once all the `1`s are gone, we get the `0`, which changes the switch to `{`. This sends the following bits into the `@`, which terminates the program. In short, we output the (unary) magnitude of the second number as many times as there are `1`s in the (unary) magnitude of the first number. [Answer] # [Python 3](https://docs.python.org/3/), 11 bytes ``` int.__mul__ ``` [Try it online!](https://tio.run/nexus/python3#S7ON@Z@ZV6IXH59bmhMf/7@gCMjTSNNILUvM0cjMKygt0dDU1EHhaWr@NzTABFxGxiAIAA "Python 3 – TIO Nexus") Also works for integers under `232` in Python 2. [Answer] # TI-Basic, 2 bytes Very straightforward. ``` prod(Ans ``` [Answer] # MATLAB, ~~5~~ 4 bytes ``` @dot ``` [`dot`](https://www.mathworks.com/help/matlab/ref/dot.html) takes the [dot product](https://en.wikipedia.org/wiki/Dot_product) of two vectors of equal length. If we feed it with two scalars, it will simply multiply the two numbers. [`prod`](https://www.mathworks.com/help/matlab/ref/prod.html) takes the product of the values in all rows of each column of a matrix. If the matrix is one-dimensional (i.e. a vector), then it acts along the non-singleton dimension, taking the product of all elements in the vector. `dot` is one byte shorter than `prod` which is one byte shorter than the even more obvious builtin [`times`](https://www.mathworks.com/help/matlab/ref/times.html). Call it as such: ``` @dot ans(3,4) ans = 12 ``` [Answer] # Java 8, ~~10~~ 9 bytes ``` a->b->ab ``` [Try it here.](https://tio.run/nexus/java-openjdk#bYwxD4IwEIV3fsWNrdFGFhe0o4mDEyNhOCqSmtIWODDE8NsrGJx0epf33ft07V1L8MABRU/aiHtvFWlnxXk9kkgZ7Dq4oravCMD3hdEKOkKaY3D6BvWMWEqttlWWQ8OXN4Cv4HixVFZlu/0p1pQSFJwC7mSxk7gpwrJOPo507KishetJ@FlPxjIl0HszMls@YRWwJtvnnP8F8Qz4IpuiKYQ4Doc3) # Java 7, 31 bytes ``` int c(int a,int b){return ab;} ``` [Try it here.](https://tio.run/nexus/java-openjdk#VYy9CoMwFEZ3n@IbkyLSDqWDT9Chk6M4XNMgAb1KctNSJM@eRujS5QzfzzEzhYDHXgFBSJxBdiww6iDVB0e9eyvRM@g0tikDWxznsvwdXqt7YiHHqhPveOoHkD6EQPcJYpdmjdJspZKZlVFs37iz2Ml6Rf150DX@o8ugtW6LIFUp52u@fQE) As full program (~~99~~ 90 bytes): ``` interface M{static void main(String[]a){System.out.print(new Long(a[0])new Long(a[1]));}} ``` [Try it here.](https://tio.run/##y0osS9TNL0jNy0rJ/v8/M68ktSgtMTlVwbe6uCSxJDNZoSw/M0UhNzEzTyO4pCgzLz06NlGzOriyuCQ1Vy@/tESvAChYopGXWq7gk5@XrpEYbRCrqYXENYzV1LSurf3//7/pf3MA) [Answer] # [Intel 8080 machine code](https://en.wikipedia.org/wiki/Intel_8080), [MITS Altair 8800](https://en.wikipedia.org/wiki/Altair_8800), 28 bytes This implements [binary multiplication](https://en.wikipedia.org/wiki/Multiplication_algorithm#Peasant_or_binary_multiplication) on the [Intel 8080 CPU](https://en.wikipedia.org/wiki/Intel_8080) (c. 1974) which did not have multiplication or division instructions. Inputs are 8-bit values and the product is a 16-bit value returned in the `BC` register pair. Here is the machine code along with step-by-step instructions to load the program into an [Altair 8800](https://en.wikipedia.org/wiki/Altair_8800) using the front panel switches. ``` Step Switches 0-7 Control Switch Instruction Comment 1 RESET 2 00 001 110 DEPOSIT MVI C, 5 Load multiplier into C 3 00 000 101 DEPOSIT NEXT value is 5 4 00 010 110 DEPOSIT NEXT MVI D, 16 Load multiplicand into D 5 00 010 000 DEPOSIT NEXT value is 16 6 00 000 110 DEPOSIT NEXT MVI B, 0 clear B register (high byte of result) 7 00 000 000 DEPOSIT NEXT 8 00 011 110 DEPOSIT NEXT MVI E, 9 set loop counter E multiplier size 9 00 001 001 DEPOSIT NEXT (8 bits + 1 since loop ends in middle) 10 01 111 001 DEPOSIT NEXT MOV A, C move multiplier into A for shift 11 00 011 111 DEPOSIT NEXT RAR shift right-most bit to CF 12 01 001 111 DEPOSIT NEXT MOV C, A move back into C 13 00 011 101 DEPOSIT NEXT DCR E decrement loop counter 14 11 001 010 DEPOSIT NEXT JZ 19 00 loop until E=0, then go to step 27 15 00 011 001 DEPOSIT NEXT 16 00 000 000 DEPOSIT NEXT 17 01 111 000 DEPOSIT NEXT MOV A, B move sum high byte into A 18 11 010 010 DEPOSIT NEXT JNC 14 00 add if right-most bit of 19 00 010 100 DEPOSIT NEXT multiplier is 1, else go to 22 20 00 000 000 DEPOSIT NEXT 21 10 000 010 DEPOSIT NEXT ADD D add shifted sums 22 00 011 111 DEPOSIT NEXT RAR shift right new multiplier/sum 23 01 000 111 DEPOSIT NEXT MOV B, A move back into B 24 11 000 011 DEPOSIT NEXT JMP 08 00 go to step 10 25 00 001 000 DEPOSIT NEXT 26 00 000 000 DEPOSIT NEXT 27 11 010 011 DEPOSIT NEXT OUT 255 display contents of A on data panel 28 11 111 111 DEPOSIT NEXT 30 01 110 110 DEPOSIT NEXT HLT Halt CPU 31 RESET Reset program counter to beginning 32 RUN 33 STOP ``` [Try it online!](https://s2js.com/altair/sim.html) If you've entered it all correctly, on the machine state drawer in the simulator your RAM contents will look like: ``` 0000 0e 05 16 10 06 00 1e 09 79 1f 4f 1d ca 19 00 78 0010 d2 14 00 82 1f 47 c3 08 00 d3 ff 76 ``` Input Multiplier in `C` register, and multiplicand into `D`. The stock Altair has no `STDIN` so input is by front panel switches only. Output The result is displayed on the `D7`-`D0` lights (top right row) in binary. `5 x 16 = 80 (0101 0000)` [![enter image description here](https://i.stack.imgur.com/7qssy.png)](https://i.stack.imgur.com/7qssy.png) `4 x 5 = 20 (0001 0100)` [![enter image description here](https://i.stack.imgur.com/2yC06.jpg)](https://i.stack.imgur.com/2yC06.jpg) `7 x 9 = 63 (0011 1111)` [![enter image description here](https://i.stack.imgur.com/guPTi.png)](https://i.stack.imgur.com/guPTi.png) `8 x -9 = -72 (1011 1000)` [![enter image description here](https://i.stack.imgur.com/ytTE3.png)](https://i.stack.imgur.com/ytTE3.png) Compatibility note: this should also run on the [IMSAI 8080](https://en.wikipedia.org/wiki/IMSAI_8080), though currently untested. [Answer] ## Pyth, 2 bytes ``` E ``` [Try it here!](http://pyth.herokuapp.com/?code=%2aE&input=2%0A3&debug=0) Pyth's automatic evaluation gets in the way here. To get around it, I'm using explicit evaluation for one of the arguments [Answer] # PHP, 21 bytes ``` <?=$argv[1]$argv[2]; ``` takes input from command line arguments. Also works with floats. [Answer] ## [Retina](https://github.com/m-ender/retina), ~~39~~ 35 bytes Thanks to Leo for letting me use an idea of his that ended up saving 4 bytes. ``` [^-] \)`-- .+ $ \G1 _ _\|1+ $' 1 ``` Input is linefeed-separated. [Try it online!](https://tio.run/nexus/retina#HcjBDYAgEETR@1SxB42IWbNLNGIFFOBRFHrwau8IXibzfm@OHB@YkMt58wXYOGZmYJ7QWcSgSEivVg3QUpQcFlqx0Q525OGJ6/tXKoW4NWlJquQD) (Space-separated test suite for convenience.) ### Explanation The first two stages print a minus sign if exactly one of the two inputs is negative. They do this without actually changing the input. This is done by grouping them in the second stage with `)` and turning them into a dry-run with ``. The `\` option on the second stage prevents printing a trailing linefeed. ``` [^-] ``` First, we remove everything except the minus signs. ``` \)`-- ``` Then we cancel the minus signs if there are two of them left. ``` .+ $* ``` Now we convert each line to the unary representation of its absolute value. This will get rid of the minus sign because `$` only looks for the first non-negative number in the match (i.e. it doesn't know about minus signs and ignores them). ``` \G1 _ ``` The first line is converted to `_`, by matching individual `1`s as long as their adjacent to the previous match (hence, we can't match the `1`s on the second line, because the linefeed breaks this chain). ``` _\|1+ $' ``` This performs the actual multiplication. We replace each `_` (on the first line) as well as the entire second line everything after* that match. The `_` matches will therefore include the entire second line (multiplying it by the number of `0`s in the first line), and the second line will be removed because there is nothing after that match. Of course the result will also include some junk in the form of `_`s and linefeeds, but that won't matter. ``` 1 ``` We finish by simply counting the number of `1`s in the result. [Answer] # [PigeonScript](https://github.com/PigeonScript/PigeonScript), 1 byte ``` * ``` Explanation: `` looks to the stack to see if there is anything there. If not, it prompts for input and multiplies the inputs together [Answer] # [Perl 6](http://perl6.org/), 4 bytes ``` &[] ``` This is just the ordinary infix multiplication operator ``, expressed as an ordinary function. As a bonus, if given one number it returns that number, and if given no numbers it returns `1`, the multiplicative identity. [Answer] # [Owk](https://github.com/phase/owk), 11 bytes ``` λx.λy.xy ``` This can be assigned to a function like this: ``` multiply:λx.λy.xy ``` and called like this: ``` result<multiply(a,b) ``` [Answer] # ><>, 5 Bytes ``` i\|;n ``` Takes input as an ascii character, outputs a number. ### Explanation: ``` i \| Get input. \| \| Mirror: Change the pointer's direction. i \| Get input again. * \| Loop around to the right side. Multiply n \| Print the value on the stack, as a number ; \| End the program ``` You could also do ``` iin; ``` But I feel my solution is waaay* cooler. Another possibility is dropping the semicolon, which would result in the pointer bouncing off the mirror, hitting the print command, and throwing an error since the stack is empty. [Answer] # [BitCycle](https://github.com/dloscutoff/esolangs/tree/master/BitCycle), 33 bytes ``` >>\/v ?+ \/ ? +~!/ A + = ~BC^ ``` [Try it online!](https://tio.run/##S8osSa5Mzkn9/1/Bzi5Gv4zLXlshRp/LXkG7TlGfS8FRQVvBlktBoc7JOe7///@mBv91jY3@5ReUZObnFf/XDQUA "BitCycle – Try It Online") This takes input via command line args, with the `-U` flag to convert it into signed unary. This only uses one pair of collectors in the main loop by representing the first number with unary `0`s and the other number with `1`s, allowing us to store both in the same collector. ### Explanation: No fancy gifs sorry. This also assumes you have at least a passing familiarity with BitCycle. ``` ?+ Get both numbers as signed unary from the ? sources ? + Sends 0s upwards (0s signify that the number is negative), and 1s downwards ``` ``` >>\/v Given either 0, 1 or 2 zeroes + \/ + !/ Push a 0 (signifying negative) if there is exactly one 0 ``` ``` + Push the first number as unary 1s to collector A + Push the second number as unary 0s to collector B A + Then push the first number into collector B ~BC Then push both into collector C ``` ``` / If the first bit out of collector C is 0 + = Turn the = into { and discard the first bit BC^ All the 0s go back to collector B, and the 1s go up ``` ``` +~! Duplicate and print all the 1s + Push the duplicates back into B ~B ``` This loops until it runs out of `0s` in the collector, then the `=` turns into a `}` and discards the rest of the `1` bits. [Answer] ## C#, 10 bytes ``` a=>b=>a*b; ``` It's just a simply multiplication. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 1 byte ``` × ``` [Try it online!](https://tio.run/nexus/jelly#@394@v///y3@61oCAA "Jelly – TIO Nexus") Obligatory Jelly submission. ]
[Question] [ ## Challenge Let's have a list `L` of `n` elements. The task is to swap every two elements in this list. ## Constrains * the list `L` has at least two elements * size of the list `L` is a multiple of two (i.e. number of elements is even) ### Example * input: `[1,2,3,4,5,6]` * output: `[2,1,4,3,6,5]` * input: `[0,1,0,1]` * output: `[1,0,1,0]` ## Rules * this is `code-golf` challenge, so the shortest code wins * [standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer with [default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/), so you are allowed to use stdin/stdout, functions/method with the proper parameters and return-type, full programs * [default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden. [Answer] # [><>](https://esolangs.org/wiki/Fish), ~~4~~ 3 bytes ``` i#o ``` [Try it online!](https://tio.run/##S8sszvj/PzMzP///f0MjYxNTMwA "><> ‚Äì Try It Online") Lol, ><> ~~ties with~~ beats Jelly & 05AB1E. Terminates with an error. -1 thanks to @Manny Queen. # How does it work? ``` The instruction pointer (IP) is currently moving right i Take input as a character # Reflect - The IP starts moving left i Take input again o Output that # Reflect - The IP starts moving right again o Output the first input we took - the inputs are now swapped And now, we're moving left and back at the start again on i + moving right. This loops forever (i.e. until erroring when we're out of input) because there is no halt instruction (;) This is essentially executing "iioo" in an infinite loop. ``` [Answer] # [Python 3](https://docs.python.org/3/), 34 bytes ``` f=lambda l:l and l[1::-1]+f(l[2:]) ``` [Try it online!](https://tio.run/##K6gsycjPM/7/P802JzE3KSVRIccqRyExL0UhJ9rQykrXMFY7TSMn2sgqVvN/QVFmXolGmka0oY6RjrGOiY6pjlmspuZ/AA "Python 3 ‚Äì Try It Online") When `l` is empty (which makes it falsy), return it directly. Otherwise, reverse the first two elements and make a recursive call for the rest. [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal) `r`, 2 bytes ``` yY ``` [Try it Online!](https://lyxal.pythonanywhere.com?flags=r&code=yY&inputs=%5B1%2C2%2C3%2C4%2C5%2C6%5D&header=&footer=) Explanation: ``` y # Uninterleave Y # Interleave ``` [Answer] # [Haskell](https://www.haskell.org/), 22 bytes ``` f(a:b:c)=b:a:f c f x=x ``` [Try it online!](https://tio.run/##y0gszk7Nyfn/P00j0SrJKlnTNskq0SpNIZkrTaHCtuJ/bmJmnoKtQkq@ApdCQVFmXomCikJatKGenlksioCOgQ4Ux/4HAA "Haskell ‚Äì Try It Online") [Answer] # [convey](http://xn--wxa.land/convey/), 7 bytes I knew I should have implemented SpaceChem's flipflop operator, then this would be 5 bytes. :-) -6 byte by @Manny Queen ``` }?{ }~1 ``` [Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoifT97XG59fjEiLCJ2IjoxLCJpIjoiMSAyIDMgNCA1IDYifQ==) `{` puts the input list on the conveyor, `}` prints the result. On the `?` the elements try to go down if they can. On the `~` they will wait for `1` tick before going to the output, thus starting with the first item, every second element is delayed for two ticks. ### 13 bytes ``` },< {@^ 0" 1^ ``` [Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoifSw8XG57QF5cbjBcIlxuMV4iLCJ2IjoxLCJpIjoiMSAyIDMgNCA1IDYifQ==) The lower loop `0"\1^` copies `0 1 0 1 ‚Ä¶` into choose `@`. The input is thus split into two paths. The right one takes a little bit longer, so the other number can overtake it before joining `,` again. [![variant 2 with input 1 to 6](https://i.stack.imgur.com/d4SqQ.gif)](https://i.stack.imgur.com/d4SqQ.gif) [Answer] # [brainfuck](https://github.com/TryItOnline/brainfuck), 9 bytes ``` ,[>,.<.,] ``` [Try it online!](https://tio.run/##SypKzMxLK03O/v9fJ9pOR89GTyf2/39DI2MTUzMA "brainfuck ‚Äì Try It Online") [Answer] # [Rust](https://www.rust-lang.org/) v1.37.0, ~~59~~ ~~55~~ 47 bytes ``` \|a:&[_]\|(0..).zip(a).map(\|i\|a[i.0^1]).collect() ``` [Try it online!](https://tio.run/##Lc1NDoIwFATgtZ7iyYK0ybPhR12g4C3cEDQNwaRJKQ2UmEg5e63AajbfzPTjYNxbQcuFIhSm/U42BoYP10PuLM/C8lVZEjFG2VdowilruSZWWF4KFj3jirK6k7KpDaHuuraF0qOBHMoYIUFIEU4IZ4RLtYFuNF5k8Gjqm0iTwtvlkYRLlXqme6GMVAcSTNl9hmMB/wxwHcdtwsvZ/QA "Rust ‚Äì Try It Online") -2 bytes thanks to ZippyMagician -2 bytes thanks to alephalpha -8 bytes thanks to `(0..).zip(a)` Rust is not a golfy language... Port of the [C#](https://codegolf.stackexchange.com/a/237101/44998) and [JS](https://codegolf.stackexchange.com/a/237108/44998) answers v1.37.0 is the version available on TIO # [Rust](https://www.rust-lang.org/) stable, 54 bytes ``` \|a:&[_]\|a.chunks(2).flat_map(\|a\|[a[1],a[0]]).collect() ``` [Try it online!](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=303e751fa22451f42bc9f876119481cd) Thanks to ZippyMagician for this slightly golfier answer on the latest version of Rust. [Answer] # [Python 2](https://docs.python.org/2/), 30 bytes ``` def f(a,b,m):print b,a,;f(m) ``` [Try it online!](https://tio.run/##HYs7DsMgEAV7TrElWK8IzqcgtW@QznJhJ4uMlGCENrI5PUEpphnNpCLrFvtaX@zJ6xkLuo9xKYcotGDG3esm6r6GN5N1iiQX18ouxPQVbYwiPp6chB4l8ZDzlh399zpa9DjjgitukxpPsGhMPw "Python 2 ‚Äì Try It Online") The function `f` takes input splatted like `f(1,2,3,4,5,6)`, and prints the output space-separated, terminating with error. --- 34 bytes ``` lambda l:map(l.pop,len(l)/2[1,0]) ``` [Try it online!](https://tio.run/##DcpLCoAgEADQfadwqTGU2mchdJJyYVQojDaEEZ3eWr9Hb/Zn0uWYloIurptjaKIjjg2dBLgnjqLV9axAWlEeH3BnytAVUmYHD4nuzIUov2vooIcBRlvNEv4Pyn4 "Python 2 ‚Äì Try It Online") This works by alternating popping the elements at index `1` and index `0`. [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 22 bytes ``` 0<##<1\|\|#2&&#&&#0@##3& ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b738BGWdnGsKZG2UhNTRmIDByUlY3V/geWZqaWOAQUZeaVRCvr2qU5OCjHqtUFJyfm1VVzVRvqGOkY65jomOqY1epwVRvoGOoAMYRpUMtV@x8A "Wolfram Language (Mathematica) ‚Äì Try It Online") Input `[L...]`, and returns in an `And`. Works on integer inputs. --- ### [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 24 bytes ``` {}=={##}\|\|#2&&#&&#0@##3& ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7v7rW1rZaWbm2pkbZSE1NGYgMHJSVjdX@B5ZmppY4BBRl5pVEK@vapTk4KMeq1QUnJ@bVVXNVG@oY6RjrmOiY6pjV6nBVG@gY6gAxhGlQy1X7HwA "Wolfram Language (Mathematica) ‚Äì Try It Online") Input `[L...]`, and returns in an `And`. Works on non-boolean inputs. ### [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 26 bytes ``` #2~##&~#&@@@#~Partition~2& ``` [Try it online!](https://tio.run/##DcM7CoAwDADQvdcIdIqg9bMpOULBURxCUexgBclWmqtXH7yb5Tpulhi4nnMFpwBWwRIRqOdXosQnqbPVvzHJBs1yEuxW18BJs8kdOuxxwBGngia32OG/mFI/ "Wolfram Language (Mathematica) ‚Äì Try It Online") Input `[L]`, and returns a list. Works. [Answer] # JavaScript (ES6), 23 bytes ``` x=>x.map((_,i)=>x[i^1]) ``` The `[i^1]` is thanks to m90 in TNB [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z@TWqJQXJ5YUGz7P9HWLlEvN7FAQyNeJ1MTyInOjDOM1QQrycwrKC1RsFWINtQx0jHWMdEx1TGLteZKzs8rzs9J1cvJT9dIUKkGq6pV0LVTUKkGG6oBFtGsTdC0/g8A) [Answer] # [Python 3](https://docs.python.org/3/), 36 bytes ``` lambda a:sum(zip(a[1::2],a[::2]),()) ``` [Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHRqrg0V6Mqs0AjMdrQysooVicxGkRp6mhoav4vKMrMK9FI04g21DHSMdYx0THVMYsFigMA "Python 3 ‚Äì Try It Online") [Answer] # [Python 3](https://docs.python.org/3/) + numpy, 31 bytes ``` lambda m:m[~-(m==m).cumsum()^1] ``` [Try it online!](https://tio.run/##XcqxDoIwEADQna/oeJecREQdNP0SwOTAEEm841LaoQu/Xp0Z3vYsx8@qbZl9X74s45udPKTbTyDeC9ZTki0J4KsZyiK2hug0iWXHm1OrKvZqNYfAGbqGLtTSlW50H/BpYdEITDMw4uGd6e94yg8 "Python 3 ‚Äì Try It Online") Expects a numpy array. Most of the code is about avoiding referencing numpy directly, so we can avoid the explicit import. It then calculates the indices directly by xoring a counter with 1. [Answer] # [Ly](https://github.com/LyricLy/Ly), 7 bytes ``` ir[foo] ``` [Try it online!](https://tio.run/##y6n8/z@zKDotPz/2/39DI2MTUzNzCwA "Ly ‚Äì Try It Online") Pretty straightforward, but might be worth posting since it's almost pronounceable. :) ``` ir -- read input codepoints into the stack, reverse the order [ ] -- while the stack isn't empty foo -- flip the top two entries and print as characters ``` # [Cubix](https://github.com/ETHproductions/cubix), 14 bytes ``` [[email protected]](/cdn-cgi/l/email-protection)?i.o;o;.^ ``` [Try it online!](https://tio.run/##Sy5Nyqz4/19Pz0Ev0z5TL98631ov7v9/QyNjE1MzcwsA "Cubix ‚Äì Try It Online") This is the first time I've tried to use Cubix, so I wouldn't be suprised if it's possible to do this with less code. It's a hard language to explain, since it's a 2D language where the code is wrapped around a cube. So the directions the instruction pointer take a hard to show in a description. I'll include a link to the online interpreter since it has a debug mode when you can see the way the code iterates through the cells. But I'll try to explain it too... ``` [[email protected]](/cdn-cgi/l/email-protection)?i.o;o;.^ - code before it's wrapped on the cube... i - (1) starts here, input a codepoint ? - branch if top of stack, <0 "left", >0 "right" @ - "left" (true on EOF), halt program ^ - "right", set IP direction to "up" ? - same branch, but coming from another direction i - "right", input another codepoint o; - output top of stack as char, pop it off stack o; - repeat... code wraps back to (1) ``` The `.` characters are no-ops and are needed to place the other characters in the right position so they will wrap into place on the cube. Here's a link to the online interpreter <http://ethproductions.github.io/cubix/?code=Li5ALmk/aS5vO287Ll4=&input=MTIzNDU2Nzg=&speed=20> [Answer] # [C (clang)](http://clang.llvm.org/), ~~53~~ \$\cdots\$ ~~43~~ 42 bytes ``` f(l,n){l^=l[1]^(l[1]=l);n&&f(l+2,n-2);} ``` [Try it online!](https://tio.run/##nVLtToMwFP2/p2hIRgorUbqPRBH9YXyKfRhgZRJLR4BEdOHVxQstoyNLNDZpS3vOPffcWyIn4oE4NE2MbU6EdbL5zudrd7vD7erb3PKEacaYzygRDrW8uklEidIgEdhCpwmC0V6UrChf3fUW@ejkEkrmZEGWZFV7lwwqGbfEJTDHqJBokXyxY4ylpHWjjrY6E6TjdIRTaxC1O9VCispoomxomVmVsahk@949BW8L8L8iy2ss2tfY1aAn6ymSMMgSLVjxo7cgt2Fl0TvLJd/YVC90U909w1waBOnnuaHi4mOOcGsnEXtWQditpz4f@q70uYa@nG88NJt17P7hztY5SMledfjW02EkFArvM4YHQ8oMGBFdHj1HO7IcaDE2psV0D@Xh5Kkt8t4w4EH5Otlag2g9GQch5xEZlndpOoSUacD5McILW2hoytIo@8Qh4eQSiOFOjGUYyJyf7lr5WVAUwHH/VbWM7TbTRAwKRb6PQti9P7cn/LU902IjgN//UG06PSLOGcOhuqgndfMdxTw4FI3z8QM "C (clang) ‚Äì Try It Online") Inputs a pointer in an `int` array and the array's length (since pointers in C carry no length info). Swaps every two elements in place. [Answer] # [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 35 bytes ``` def f(m):m[1:],_,m[::2]=m,m[1::2] ``` [Try it online!](https://tio.run/##K6gsycjPM7YoKPr/PyU1TSFNI1fTSis32tAqVideJzfaysoo1lYrVwckAmT@T7SNNtQx0jHWMdEx1TGLtS4oyswr0UjUtE4DETAeF1iZgQ4Q41LyHwA "Python 3.8 (pre-release) ‚Äì Try It Online") In-place. Essentially a golfed version of `m[1::2],m[::2]=m[::2],m[1::2]` [Answer] # [R](https://www.r-project.org/), 29 bytes ``` function(l)l[seq(!l)+21:0-1] ``` [Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNHMye6OLVQQzFHU9tIy9DKQNcw9n@ahqGVmeZ/AA "R ‚Äì Try It Online") [Answer] # [Ruby](https://www.ruby-lang.org/), 26 bytes ``` ->l{r=-1;l.map{l[1^r+=1]}} ``` [Try it online!](https://tio.run/##KypNqvyfZvtf1y6nushW19A6Ry83saA6J9owrkjb1jC2tvZ/gUJadLShjpGOsY6JjqmOWWzsfwA "Ruby ‚Äì Try It Online") [Answer] # [J](http://jsoftware.com/), 9 bytes ``` [:,_2\|.\] ``` [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o6104o1q9GJi/2tyKXClJmfkK6QpGCoYKRgrmCiYKpj9BwA "J ‚Äì Try It Online") [Answer] # [4](https://github.com/urielieli/py-four), 22 bytes ``` 3.72082072152152072094 ``` [Try it online!](https://tio.run/##M/n/31jP3MjAwsjA3MjQFISADANLk///DY2MTUzNAA "4 ‚Äì Try It Online") Readable + explanation: ``` 3. 720 820 721 521 520 720 9 4 ^^------------------------------ mandatory prefix ^^^-------------------------- initial input in cell 20 ^^^-----------------^---- loop while cell 20 is nonzero ^^^------------------ input to cell 21 ^^^-------------- output cell 21 ^^^---------- output cell 20 ^^^------ input to cell 20 ^---- end loop ^-- exit ``` Corresponding [Quartic](https://esolangs.org/wiki/User:Conor_O%27Brien/Compilers/Quartic) program: ``` decl a, b input a loop a input b print b print a input a end ``` [Answer] # [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 43 41 bytes ``` {for(;++n<NF;n++)$n+=$(n+1)-($(n+1)=$n)}1 ``` Thanks for Dominic van Essen for 2 less bytes!* [Try it online!](https://tio.run/##SyzP/v@/Oi2/SMNaWzvPxs/NOk9bW1MlT9tWRSNP21BTVwNC26rkadYa/v9vqGCkYKxgomCqYAYA "AWK ‚Äì Try It Online") ``` { for(;++n<NF;n++) Starts a loop though the numbers. n has to start as 1, because $0 is the whole line. $n+=$(n+1)-($(n+1)=$n) Swap the numbers two by two. Readable: a += b - (b = a) } 1 Prints the line. ``` [Answer] # T-SQL, 32 bytes Input is a table variable ``` SELECT a FROM @ ORDER BY b+b%22 ``` [Try it online](https://data.stackexchange.com/stackoverflow/query/1511250/swap-every-two-elements-in-a-list)* [Answer] # [CLC-INTERCAL](https://esolangs.org/wiki/CLC-INTERCAL), ~~95~~ 67 bytes. Why does CLC-INTERCAL 1.-94.-2 lack `!1~.1'`? I could have golfed off one byte. ``` DOCOMEFROM#9(1)DOWRITEIN.1+.2DDOCOMEFROM'.1~.1'~#1(9)DOREADOUT.2+.1 ``` [Copy and paste to try it online!](http://golf.shinh.org/check.rb) ## Usage * Each item of list must be in `ONE` to `SIX FIVE FIVE THREE FIVE` (inclusive); `ZERO` for end of list. + Given from STDIN, delimited with a LF. * Outputs to STDOUT, as roman number. ## Try these inputs ``` ONE TWO ONE TWO ZERO ``` ``` ONE TWO THREE FOUR FIVE SIX ZERO ``` [Answer] # [Desmos](https://desmos.com/calculator), ~~39~~ 38 bytes ``` l=[1...L.length] f(L)=L[l-1+2mod(l,2)] ``` [Try It On Desmos!](https://www.desmos.com/calculator/xmsjvpha3x) [Try It On Desmos! - Prettified](https://www.desmos.com/calculator/qvcvjcjjpe) [Answer] # [BQN](https://mlochbaum.github.io/BQN/), ~~10~~ 9 bytes[SBCS](https://github.com/mlochbaum/BQN/blob/master/commentary/sbcs.bqn) -1 byte thanks to [Razetime](https://codegolf.stackexchange.com/users/80214/razetime)! ``` ‚•ä¬∑‚åΩÀò‚àò‚Äø2‚ä∏‚•ä ``` [Run online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4qWKwrfijL3LmOKImOKAvzLiirjipYoKCkbCqCAoMOKAvzHigL8w4oC/MSnigL8oMSvihpU2KQ==) `‚àò‚Äø2‚•äùï©` Reshape the input into a matrix with 2 columns and and the necessary number of rows. `‚åΩÀò` Reverse horizontally (Swap the 2 columns). `‚•ä` Flatten into a vector. An alternative using the Under operator at 10 bytes: ``` ‚åΩÀò‚åæ(‚àò‚Äø2‚ä∏‚•ä) ``` [Try it online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oy9y5jijL4o4oiY4oC/MuKKuOKliikKCkbCqCAoMOKAvzHigL8w4oC/MSnigL8oMSvihpU2KQ==) [Answer] # [Jelly](https://github.com/DennisMitchell/jellylanguage), 4 bytes ``` s2UF ``` [Try It Online!](https://jht.hyper-neutrino.xyz/tio#WyIiLCJzMlVGIiwiIiwiIixbIjEsMiwzLDQsNSw2Il1d) ``` s2 Slices of length 2 U Reverse each F Flatten ``` [Answer] # [Perl 5](https://www.perl.org/) -p, 21 bytes ``` s/(\S+) (\S+)/$2 $1/g ``` [Try it online!](https://tio.run/##K0gtyjH9/79YXyMmWFtTAUzqqxgpqBjqp///b6hgpGCsYKJgqmDGZaBgqADE//ILSjLz84r/6xYAAA "Perl 5 ‚Äì Try It Online") [Answer] # APL+WIN, 17 bytes Prompts for vector ``` ,‚åΩ((.5√ó‚ç¥r),2)‚ç¥r‚Üê‚éï ``` [Try it online! Thanks to Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcQJanP5BlyPWooz3tv86jnr0aGnqmh6c/6t1SpKljpAmigfJAdf@BKrj@p3EZKhgpGCuYKJgqmHGlcRkoGCoAMRcXAA "APL (Dyalog Classic) ‚Äì Try It Online") [Answer] # [Zsh](https://www.zsh.org), 18 bytes ``` for a b;<<<$b<<<$a ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwYKlpSVpuhab0vKLFBIVkqxtbGxUkkBEIkQCKr822lDHSMdYx0THVMcsFioIAA) [Answer] # [C# (.NET Core)](https://www.microsoft.com/net/core/platform) with `Linq`, ~~32~~ 26 bytes ``` a=>a.Select((n,i)=>a[i^1]) ``` [Try it online!](https://tio.run/##ZY/NSsRAEITPyVM0wUMGZgPr3yUml0VFURBy8BAijGMTGpKZdXriIiHPHmcTD7Ieq7r5qkrzRluH88BkWqi@2WOfx39V9kTm88Ta2a5D7ckazu7RoCOdx7pTzPDibOtUD2PMXnnScDcYfUPG1418uDVDj069d3h0yhL4oPZczKooVVbhkZmmRpIIuqa3bSPmPI5@QV@WPuBZkUnZu1CmbkC5lkWIiqIlAMjsBw8FGDzA6oywlXAu4ULCpYQrCdcwBWS0C9Vth9mrI49hIaZnyVgt3OzRhoxEJnLliQk2Jfw/Lt3T9UVMiQjYKZ7mHw "C# (.NET Core) ‚Äì Try It Online") -8 bytes thanks to m90's [witchcraft](https://chat.stackexchange.com/transcript/message/59572249#59572249) # [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 73 bytes ``` a=>{for(int i=0,d=0;i<a.Length;i++){d=a[i];a[i]=a[++i];a[i]=d;}return a;} ``` [Try it online!](https://tio.run/##ZY@9asQwEIRr@ykGk8LGOnP5bXRyE0gRLhC4IoVxIWzFWbiTDknOEYye3VHspEozDLPLN7ud23TGqnl0pAccvpxXJ552R@kcXq0ZrDxhSp2Xnjo8jbrbkfZNyxat4S7y7MQsRT29G5vHFCS2rBdbTjtZ7ZUe/AensiymXsiGWv4j0ZXln@95sMqPVkPyMPM0@S37NNTjRZLOnbfxuKaFtIMr4jlJstSD9Hn0ENDqgjWZcM1ww3DLcMdwz/CAEJHJo9HOHFX1ZsmrPWmVX2XTYeFWzyZ2ZCxjK68I2NT4P1xezdeVImRFxIY0zN8 "C# (.NET Core) ‚Äì Try It Online") [Answer] # [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 57 bytes ``` a:? b:0 n:0 m:3 `b Ea,Ib=n,,b:1,,x:i,+1,Ib=m,,b:0,,Oi,,Ox ``` [Try it online!](https://tio.run/##S0xJKSj4/z/Ryp4rycqAKw@Ic62MuRKSuFwTdTyTbPN0dJKsDHV0KqwydbQNQSK5IBEDHR3/TCCu@P//f7ShjpGOsY6JjqmOWSwA "Add++ ‚Äì Try It Online") Input is the first argument. ]
[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/19050/edit). Closed 6 years ago. [Improve this question](/posts/19050/edit) In a similar spirit as [this question](https://codegolf.stackexchange.com/questions/18986/draw-the-olympic-games-logo), your mission is to create the best-looking logo in at most 1K of code. Rules: 1. At most 1K of code (inclusive), no external data. 2. The answer with the most upvotes wins. Have fun! [Answer] # SVG 1kB? Luxury. I can even pretty-print the output rather than removing all unnecessary whitespace. (The indentation does, of course, use tabs, which Markdown converts to spaces, so that's why the char count might seem higher than the actual 977. Removing unnecessary whitespace drops it to 861). The overlaps are handled correctly by drawing the rings in one direction, then applying a clip and drawing them in the other direction. The colours and ratios are extracted from an [official document](http://www.olympic.org/Global/Images/Olympism%20in%20Action/Educators%20-%20OVEP/OVEP%20TOOLKIT/English/Section%202i.pdf) which for some reason uses Bézier curves rather than circles. ``` <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="504" height="228"> <defs> <clipPath id="t"> <rect width="504" height="114" /> </clipPath> </defs> <g fill="none" stroke-width="12"> <g id="u" transform="translate(82,82)" stroke="#0b8ed8"> <g id="O"> <circle r="72" stroke="#fff" stroke-width="20" /> <circle r="72" /> </g> </g> <g id="y" transform="translate(167,146)" stroke="#f9a91f"> <use xlink:href="#O" /> </g> <g id="k" transform="translate(252,82)" stroke="#231f20"> <use xlink:href="#O" /> </g> <g id="g" transform="translate(337,146)" stroke="#009e59"> <use xlink:href="#O" /> </g> <g transform="translate(422,82)" stroke="#ee2049"> <use xlink:href="#O" /> </g> <g clip-path="url(#t)"> <use xlink:href="#g" /> <use xlink:href="#k" /> <use xlink:href="#y" /> <use xlink:href="#u" /> </g> </g> </svg> ``` ![PNG render of SVG file](https://i.stack.imgur.com/Etla1.png) [Answer] # Javascript (core) – 1000 on the dot. – WebKit (Chrome) Playing with canvas. Not sure if it is 1024 or 1000 the `K` is for, but managed to get it down to 1000 982 940 :D Only suitable for WebKit browsers. Chrome OK. Firefox a mess. Might look into making it cross browser. --- ### Code: ``` var w=window;w.onload=function(){function e(e,t){return r()(t-e+1)+e}function d(e,t){function r(e,t,r,i){c.beginPath();c[u]="xor";c.strokeStyle="#"+e;c.arc(t,r,66,ni[0],ni[1]);c.stroke();c[u]="destination-atop";c.arc(t,r,66,ni[1],ni[0]);c.stroke()}var i=79+e,s=66+t,o=158,a=[2,1.2],f=[1.8,.8];c.lineWidth=13;r("007a9c",e,t,f);r("ffa100",i,s,a);r("000",e+=o,t,f);r("009b3a",i+=o,s,a);r("e10e49",e+=o,t,f)}var t=Math,n=t.PI,r=t.random,i,s,o=0,u="globalCompositeOperation",a=document.getElementById("c"),f=w.innerWidth,l=w.innerHeight,c=a.getContext("2d"),h=9,p=[];a.width=f;a.height=l;for(i=0;i<l;++i){p.push({x:r()f,y:r()l,r:e(1,3),d:e(1,l)})}setInterval(function(){c.clearRect(0,0,f,l-h);d(f/2-200,l-200);c[u]="xor";c.fillStyle="#fff";c.beginPath();o+=e(0,7)?.01:-.01;for(i=0;i<l-h;++i){s=p[i];c.moveTo(s.x,s.y);c.arc(s.x,s.y,s.r,0,n2);s.y+=t.cos(o+s.d)+1+s.r/9;s.x+=(i%2?1:-1)t.sin(o).4;if(s.x>f+7\|\|s.x<-7\|\|s.y>l-(h-1.2)){p[i]={x:r()f,y:-9,r:s.r,d:s.d}}}c.fill();if(h<l/1.7)h+=l/9e3},32)} ``` 940:* Dropped wrapping it in `onload` and rely on script being inserted at end of `body` tag + alignment bug and Firefox fix. ``` function e(e,t){return r()(t-e+1)+e}function d(e,t){function r(e,t,r,i){c.beginPath();c[u]="xor";c.strokeStyle="#"+e;c.arc(t,r,66,ni[0],ni[1]);c.stroke();c[u]="destination-over";c.arc(t,r,66,ni[1],ni[0]);c.stroke()}var i=79+e,s=66+t,o=158,a=[2,1.2],f=[1.8,.8];c.lineWidth=13;r("007a9c",e,t,f);r("ffa100",i,s,a);r("000",e+=o,t,f);r("009b3a",i+=o,s,a);r("e10e49",e+=o,t,f)}var w=window,t=Math,n=t.PI,r=t.random,i,s,o=0,u="globalCompositeOperation",a=document.getElementById("c"),f=w.innerWidth,l=w.innerHeight,c=a.getContext("2d"),h=9,p=[];a.width=f;a.height=l;for(i=0;i<l;++i,p.push({x:r()f,y:r()l,r:e(1,3),d:e(1,l)}));setInterval(function(){c.clearRect(0,0,f,l-h);d(f/2-158,l-200);c[u]="xor";c.fillStyle="#fff";c.beginPath();o+=e(0,7)?.01:-.01;for(i=0;i<l-h;++i){s=p[i];c.moveTo(s.x,s.y);c.arc(s.x+=(i%2?.4:-.4)t.sin(o),s.y+=t.cos(o+s.d)+1+s.r/9,s.r,0,n2);if(s.y>l-(h-1.2)){p[i].x=r()f;p[i].y=-9}}c.fill();if(h<l/1.7)h+=l/9e3},32) ``` ### Fiddle: <http://jsfiddle.net/Ifnak/XSBLg/embedded/result/> <http://jsfiddle.net/Ifnak/4fSWm/5/embedded/result/> Loads in Firefox as well as Chrome, but is rather heavy on resources in FF. Using `requestAnimationFrame()` helped a bit, but not enough. Note that snow lays on bottom, thus scroll down to see the slow growth. Initially had some overpainting on the ground, but could not make it fit into 1024 chr. ### Result (low quality GIF'ed screencast): ![enter image description here](https://i.stack.imgur.com/Z53Lo.gif) [Answer] ## Mathematica From my answer in [the Mathematica.SE Q&A](https://mathematica.stackexchange.com/q/8885/121): ``` ring[x_, y_, v_, t_] := Table[ {1.2 y, -v x, 0} + {Cos@i, Sin@i}.{{0, -1, 0}, {1, 0, 1/4 - v/2}}, {i, 0, 2 π, π/200} ] ~Tube~ t Graphics3D[ Riffle[ {Cyan, Yellow, Darker @ Gray, Green, Red}, Array[ring[Sqrt@3/2, #, # ~Mod~ 2, 0.17] &, 5, 0] ], Boxed -> False, ViewPoint -> {0, 0, ∞} ] ``` ![enter image description here](https://i.stack.imgur.com/Xzhlq.png) Edit: In version 10 the default lighting style changed; to render the graphic above one will need to add the Option `Lighting -> "Classic"` to `Graphics3D`. Further playing with lighting to produce a flat two-dimensional affect: ``` Graphics3D[ Riffle[ Glow /@ {Hue[.59], Hue[.13], Black, Hue[.3, 1, .7], Hue[0, 1, .85]}, Array[ring[Sqrt@3/2, #, # ~Mod~ 2, 0.13] &, 5, 0] ], Boxed -> False, ViewPoint -> {0, 0, ∞}, Lighting -> None ] ``` ![enter image description here](https://i.stack.imgur.com/SdZAC.png) --- For Oliver who said my first result was "too 3D-ish" here is an actual 2D rendering via jVincent's code with my refactoring, also from the linked thread: ``` ringSegment[mid_, deg_, color_] := {CapForm["Butt"], Thickness[0.042], White, Circle[mid, 1, deg], Thickness[0.03], RGBColor @@ (color/255), Circle[mid, 1, deg + {-0.1, 0.1}]} blue = { 0, 129, 188}; yellow = {255, 177, 49}; black = { 35, 34, 35}; green = { 0, 157, 87}; red = {238, 50, 78}; Graphics @ GraphicsComplex[ {{2.5, 0}, {1.3, -1}, {0, 0}, {5, 0}, {3.8, -1}}, ringSegment @@@ {{1, {0, 5/4 π}, black}, {2, {0, π}, yellow}, {3, {0, 2 π}, blue}, {2, {-π 9/8, 1/4 π}, yellow}, {4, {0, 5/4 π}, red}, {5, {0, 7/8 π}, green}, {1, {5/4 π, 5/2 π}, black}, {5, {7/8 π, 2 π}, green}, {4, {-3/4 π, 1/4 π}, red}} ] ``` ![enter image description here](https://i.stack.imgur.com/MNA04.png) [Answer] ## Ruby, 321 Sadly, a certain head of state seems to be the headline subject of most Olympic news so far. Thus, here is my freestyle logo (mascot?) for the 2014 Games. ``` w=?$;"UW[NASY_LAQVgKAPSlKAOKGLnHAOIHMnHAOHILpHANHJLqFAOFLKAVMAVMAWKAWLAWKAMIHFGK NFMLAMGOFFGAGJPGFIAHGFFOWPPAIGFFKQFOKMJHAIJJQGNLGFMAJIJNFIGHFHSGASMMFHHASHGGPK MFJHTKARJSKAMGFOPJAPPOJAPRKLAQRJLAQTHLAR^LFARaARaAR]HFASZAS[FFRGAT_QGAUZGFFG U]AQGITAPHKPANKKSALMNSGGAJPOP".codepoints{\|r\|r-=69;$><<(r<0??\n:(w=w==?$?' ':?$)r)} ``` Output: (Back up and squint. Sorry for the primitive rendering but he deserves no better.) ![Putin](https://i.stack.imgur.com/Ezfrz.png) [Answer] # Bash + ImageMagick ``` convert \ -size 330x150 xc:white -strokewidth 10 -fill none \ -stroke \#0885c2 -draw 'arc 100,100 10,10 0,360' \ -stroke black -draw 'arc 210,100 120,10 0,360' \ -stroke \#ed334e -draw 'arc 320,100 230,10 0,360' \ -stroke \#fbb132 -draw 'arc 155,140 65,50 0,360' \ -stroke \#1c8b3c -draw 'arc 265,140 175,50 0,360' \ -stroke \#0885c2 -draw 'arc 100,100 10,10 -20,10' \ -stroke black -draw 'arc 210,100 120,10 -20,10' -draw 'arc 210,100 120,10 90,120' \ -stroke \#ed334e -draw 'arc 320,100 230,10 90,120' \ x: ``` Sample output: ![olympic games logo](https://i.stack.imgur.com/evnzs.png) [Answer] # FreePascal Winter Olympics? How about some fractal snowflakes instead of regular rings. The recursion for the centre branch is pretty obvious: (dx,dy)= 0.5(dx,dy). Left and right branches are based on rotation by matrix multiplication: x= x cos(a) - y sin(a) y= x sin(a) + y cos(a) 1/4 = 0.5 cos(60) and 7/16 is a good approximation of 0.5 sin(60). ``` uses graph; var gd, gm : integer; var n:integer; Procedure tree(x,y,dx,dy: integer); begin if dxdx+dydy>0 then begin line(x, y, x+dx, y+dy); tree(x+dx, y+dy, dx div 2, dy div 2); tree(x+dx, y+dy, dx div 4 + dy7 div 16, dy div 4 - dx7 div 16); tree(x+dx, y+dy, dx div 4 - dy7 div 16, dy div 4 + dx7 div 16); end; end; begin gd := D4bit; gm := m640x480; initgraph(gd,gm,''); setbkcolor(white); clearviewport; setbkcolor(black); setlinestyle(0,0,3); For n:=-1 to 1 do begin setColor(yellow); tree(215,240-120n,0,120n); setColor(lightgreen); tree(425,240-120n,0,120n); setColor(black); tree(320,120-120n,0,120n); setColor(lightred); tree(530,120-120n,0,120n); setColor(lightblue); tree(110,120-120n,0,120n); end; readln; closegraph; end. ``` . . ![image](https://i.stack.imgur.com/fYiGb.png) [Answer] # Commodore 64 BASIC Again, a C64 answer, but this time I'm allowed to use sprites! Yay! I remember if you wanted to use sprites, you'd begin your program with a lots of boring `DATA` statements. To define a "high resolution" (24x21 pixels) monochromatic sprite pattern you need 63 bytes. There's actually an online [sprite editor](http://www.ccpssolutions.com/tools/c64se/) that calculates the DATA for you, so: ``` 10 DATA 0,254,0,3,255,128,7,255,192,15,131,224,30,0,240,60,0,120,56,0,56,120,0 20 DATA 60,112,0,28,112,0,28,112,0,28,112,0,28,112,0,28,120,0,60,56,0,56,60,0 30 DATA 120,30,0,240,15,131,224,7,255,192,3,255,128,0,254,0 ``` I'll also need some more DATA for the [colours](http://www.c64-wiki.com/index.php/Color) and positions. I just copied that from my answer to the original [Olympic Games Logo](https://codegolf.stackexchange.com/questions/18986/draw-the-olympic-games-logo) question: ``` 40 DATA 6,0,0,0,2,0,2,4,0,7,1,1,5,3,1 ``` Then, you'd usually set `V=53248`. This `53248` must be an important number, because I still remember it 25 years later :) It turns out it is the base address of VIC-II (Video Interface Controller): ``` 50 V=53248 ``` Then I read the sprite pattern into the memory starting at the address `832`. It feels weird to just write to a memory location, no allocating, no `new`, nothing like that :) The start address needs to be a multiple of 64. ``` 60 FOR I=0 TO 62 70 READ D:POKE 832+I,D 80 NEXT I ``` I'll be using the same pattern for all the sprites. ``` 90 FOR I=0 TO 4 100 READ C,X,Y ``` `C` is the colour code, `X` and `Y` are horizontal and vertical positions of the circles. A few more `POKE`s are needed: ``` 110 POKE V+I2,150+X11 120 POKE V+I2+1,130+Y10 ``` `V+0`, `V+2`, `V+4`, etc... are the horizontal locations of each sprite, while `V+1`, `V+3`, `V+5`... are vertical. The sprite colours start at the register `V+39`: ``` 130 POKE V+39+I,C ``` The sprite data pointers start at `2040`, and since the data starts at `832`, we get `832/64`=`13`, so: ``` 140 POKE 2040+I,13 150 NEXT I ``` To turn on the sprites I set bits `0-4` of the register `V+21`. I also changed the background to white, so we can see the blue circle. ``` 160 POKE 53281,1 170 POKE V+21,31 ``` That's it! ![Olympic sprites](https://i.stack.imgur.com/57BI0.png) [Answer] ## Java Similar to my SVG answer, but Uses two clips, to avoid slight discrepancies due to double-drawing with anti-alias. * Because Java has actual loops, the structure is a bit nicer. Note that I've not tried to golf it, despite the possibility of some interesting tricks (like `-57~dir` instead of `57(1+dir)`. It's at 923 chars, but golfs down to 624 quite easily. ``` import java.awt.; import java.awt.image.BufferedImage; import java.io.File; import javax.imageio.ImageIO; public class Rings { public static void main(String[] args) throws Exception { int[] pal = new int[] {0x0b8ed8, 0xf9a91f, 0x231f20, 0x009e59, 0xee2049}; BufferedImage img = new BufferedImage(505, 229, BufferedImage.TYPE_INT_ARGB); Graphics2D g = img.createGraphics(); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); for (int dir = -1; dir < 2; dir += 2) { g.setClip(0, 57 (1 + dir), 520, 114); for (int ring = 2 - 2 * dir; ring != 2 + 3 * dir; ring += dir) { for (int subring = 0; subring < 2; subring++) { g.setColor(new Color(pal[ring] \| (subring - 1))); g.setStroke(new BasicStroke(20 - 8 * subring)); g.drawOval(10 + 85 * ring, 10 + 64 * (ring & 1), 144, 144); } } } ImageIO.write(img, "PNG", new File("rings.png")); } } ``` ![PNG rendered by Java program](https://i.stack.imgur.com/VBxTR.png) [Answer] ## LaTeX/TikZ Size: 876 bytes (12 lines, line with 72 characters and end of line) ``` \documentclass{standalone}\usepackage{tikz}\def\W{3.762bp}\def\R{71.682 bp}\def\D{12.9041bp}\usetikzlibrary{calc,hobby}\def\Y{-71.7013bp}\def\X {169.5538bp}\begin{document}\tikz[use Hobby shortcut,every path/.style= {line width=\W,double distance=\D, white}]{\def\Z{coordinate}\path(0,0) \Z(A)++(\X,0)\Z(C)++(\X,0)\Z(E)($(A)!.5!(C)$)++(0,\Y)\Z(B)++(\X,0)\Z(D) ;\def~#1#2{\definecolor{#1}{cmyk}{#2}} ~A{1,.25,0,0}~B{0,.342,.91,0}~C{ 0,0,0,1}~D{1,0,.91,.06}~E{0,.94,.65,0}\def~#1#2#3#4{\draw[save Hobby p% ath={#1},double=#1,overlay](#1)+([closed] 225:\R)..+([#2]315:\R)..+([#3 ]45:\R)..+([#4]135:\R); \path let\n!={\R+\D/2}in(#1)+(-\n!,0)+(\n!,0)+( 0,-\n!)+(0,\n!);}\def\0#1{\draw[double=#1,restore and use Hobby path={% #1}{disjoint,invert soft blanks}];}~A{}{blank=soft}{}~B{}{}{blank=soft} ~C{}{blank=soft}{}\0B\0A~E{blank=soft}{}{}~D{}{}{}\0C\0E}\end{document} ``` > > ![enter image description here](https://i.stack.imgur.com/Uzn52.png) > > > Size: 817 bytes in one line and with two optimizations: * Option `tikz` of class `standalone`, see [comment](https://codegolf.stackexchange.com/questions/19050/olympic-games-logo-free-style-edition/20329?noredirect=1#comment285701_20329) of Wheat Wizard. * The multiple uses of `soft=blank` can be shortened by defining a style `b`. ``` \documentclass[tikz]{standalone}\def\W{3.762bp}\def\R{71.682bp}\def\D{12.9041bp}\usetikzlibrary{calc,hobby}\def\Y{-71.7013bp}\def\X{169.5538bp}\begin{document}\tikz[use Hobby shortcut,every path/.style={line width=\W,double distance=\D,white},b/.style={blank=soft}]{\def\Z{coordinate}\path(0,0)\Z(A)++(\X,0)\Z(C)++(\X,0)\Z(E)($(A)!.5!(C)$)++(0,\Y)\Z(B)++(\X,0)\Z(D);\def~#1#2{\definecolor{#1}{cmyk}{#2}} ~A{1,.25,0,0}~B{0,.342,.91,0}~C{0,0,0,1}~D{1,0,.91,.06}~E{0,.94,.65,0}\def~#1#2#3#4{\draw[save Hobby path={#1},double=#1,overlay](#1)+([closed]225:\R)..+([#2]315:\R)..+([#3]45:\R)..+([#4]135:\R); \path let\n!={\R+\D/2}in(#1)+(-\n!,0)+(\n!,0)+(0,-\n!)+(0,\n!);}\def\0#1{\draw[double=#1,restore and use Hobby path={#1}{disjoint,invert soft blanks}];}~A{}b{}~B{}{}b~C{}b{}\0B\0A~E b{}{}~D{}{}{}\0C\0E}\end{document} ``` ## LaTeX/TikZ (readable version) The following longer version is probably easier to understand. * The overlapping of the rings is handled by drawing the rings with blank segments first. Then at a later stage, the rings are drawn again, but this time the blank segments are filled and the other already drawn segments of the rings remain untouched. Therefore clipping is not used at all. * The ring with the white margins is drawn by circle with a double line. The area between the lines is filled with the color of the ring and the thinner double lines form the outer and inner white margin. * The colors and dimensions are taken from the PDF page description of page 5 of the [official document](http://www.olympic.org/Global/Images/Olympism%20in%20Action/Educators%20-%20OVEP/OVEP%20TOOLKIT/English/Section%202i.pdf#page=5) (see the [answer](https://codegolf.stackexchange.com/a/19100) of Peter Tayler). ``` \nofiles % .aux file is not needed \documentclass[tikz]{standalone} \usetikzlibrary{calc} \usetikzlibrary{hobby} \newcommand{\xshift}{169.5538bp} \newcommand{\yshift}{-71.7013bp} \newcommand{\radius}{71.6821bp} \newcommand{\whitelinewidth}{3.762bp} \newcommand{\colorlinewidth}{12.9041bp} \definecolor{color@A}{cmyk}{1, .25, 0, 0} \definecolor{color@B}{cmyk}{0, .342, .91, 0} \definecolor{color@C}{cmyk}{0, 0, 0, 1} \definecolor{color@D}{cmyk}{1, 0, .91, .06} \definecolor{color@E}{cmyk}{0, .94, .65, 0} \begin{document} \begin{tikzpicture}[ use Hobby shortcut, every path/.style = { line width = \whitelinewidth, double distance = \colorlinewidth, white, }, ] % define center coordinates for the five rings \path (0,0) coordinate (center@A) ++(\xshift, 0) coordinate (center@C) ++(\xshift, 0) coordinate (center@E) ($(center@A)!.5!(center@C)$) ++(0, \yshift) coordinate (center@B) ++(\xshift, 0) coordinate (center@D) ; % \drawring draws the first part of the ring with blank parts \newcommand{\drawring}[4]{% \draw[ save Hobby path = {path@#1}, double = {color@#1}, overlay, ] (center@#1) +([closed] 225:\radius) .. +([#2] 315:\radius) .. +([#3] 45:\radius) .. +([#4] 135:\radius) ; } % \finishring draws the blank parts of the rings \newcommand{\finishring}[1]{% \draw[ double = {color@#1}, restore and use Hobby path = {path@#1}{ disjoint, invert soft blanks }, ]; } \drawring{A}{}{blank=soft}{} \drawring{B}{}{}{blank=soft} \drawring{C}{}{blank=soft}{} \finishring{B} \finishring{A} \drawring{E}{blank=soft}{}{} \drawring{D}{}{}{} \finishring{C} \finishring{E} % set calculated bounding box \useasboundingbox let \n{r} = {\radius + \colorlinewidth/2} in (center@A) +(-\n{r}, \n{r}) % upper left corner (center@B -\| center@E) +(\n{r}, -\n{r}) % lower right corner ; \end{tikzpicture} \end{document} ``` [Answer] C++ 1024 bytes* Updated: Now with antialiasing. Code has been somewhat de-golfed while still fitting in (exactly) 1K. Doesn't use any library functions except ostream functions to write output file. ``` #include <fstream> namespace { typedef double d; int w=512; d a=1./6,g=1./w,h=1./72,j=h+g,k=h-g,r=5./36; struct p{d x,y;}ps[]={{5a,a},{4a,2a},{3a,a},{2a,2a},{a,a}}; struct c{unsigned char r,g,b;}cs[]={{237,51,78},{28,139,60},{0,0,0},{251,177,50},{8,133,194}}; d abs(d x) {return x<0?-x:x;} d sqrt(d x) { d e=1e-6,y=1; for(;abs(yy-x)>e;y=.5(y+x/y)); return y; } d dist(p c,p z) { d u=z.x-c.x,v=z.y-c.y; return abs(r-sqrt(uu+vv)); } c lerp(c a,c b,d t) { auto l=[=](d a,d b){return a+(b-a)t;}; return {l(a.r,b.r),l(a.g,b.g),l(a.b,b.b)}; } d smoothstep(d z) { z=(z-j)/(k-j); z=z<0?0:z>1?1:z; return zz(3-2z); } c color(p z) { c o{255,255,255}; for(int i=0,j;i<5;++i){ j=z.y<.25?i:4-i; o=lerp(o,cs[j],smoothstep(dist(ps[j],z))); } return o; } } int main() { std::ofstream o("r.ppm",std::ofstream::binary); o<<"P6 "<<w<<" "<<w/2<<" 255\n"; for(int y=0;y<w/2;++y) for(int x=0;x<w;++x) o.write((char)&color(p{xg,yg}),3);; } ``` Outputs a .ppm file: ![enter image description here](https://i.stack.imgur.com/FRJLx.png) [Answer] # R, 70 characters Using CRAN-R statistics. ``` l=c(1,9);plot(3:7,c(6,4,6,4,6),col=c(4,7,1,3,2),cex=10,ylim=l,xlim=l) ``` ![R plot](https://i.stack.imgur.com/bRjum.png) [Answer] # GLSL I feel like I'm a little late to the party, but maybe I can make up for that with the first GLSL submission on this site. It is meant to be used as the fragment shader for a screen-filling primitive, and expects the viewport resolution in the `iResolution` uniform. Colors and positions are "borrowed" from [Peter Taylor's submission](https://codegolf.stackexchange.com/a/19100/15293). I had to shorten some variable names to get below 1024 characters, but I hope it's still readable. See it at [Shadertoy](https://www.shadertoy.com/view/Xs23RK) (if your browser supports WebGL). ``` uniform vec3 iResolution; float circle(vec2 pos, float r) { return clamp(r - distance(gl_FragCoord.xy, pos), 0., 1.); } float ring(vec2 pos, float r, float d) { return circle(pos, r + d) (1. - circle(pos, r - d)); } void paint(vec3 color, float a) { gl_FragColor.rgb = mix(gl_FragColor.rgb, color, a); } void main() { struct r_t { vec2 pos; vec3 col; } rs[5]; rs[0] = r_t(vec2( 82, 146), vec3(.04, .56, .85)); rs[1] = r_t(vec2(167, 82), vec3(.98, .66, .12)); rs[2] = r_t(vec2(252, 146), vec3(.14, .12, .13)); rs[3] = r_t(vec2(337, 82), vec3(.00, .62, .35)); rs[4] = r_t(vec2(422, 146), vec3(.93, .13, .29)); float s = min(iResolution.x / 504., iResolution.y / 228.); vec2 b = (iResolution.xy - vec2(504, 228) * s) * .5; bool rev = gl_FragCoord.y > iResolution.y * .5; gl_FragColor.rgb = vec3(1); for (int i = 0; i < 5; ++i) { r_t r = rev ? rs[4 - i] : rs[i]; paint(vec3(1), ring(r.pos * s + b, 72. * s, 11. * s)); paint(r.col, ring(r.pos * s + b, 72. * s, 6. * s)); } } ``` ![Resulting rendering](https://i.stack.imgur.com/OkjaW.png) [Answer] # Mathematica I've replaced my original answer with one that draws on regions and their intersections. The code size is 973 bytes, ungolfed. Regions 1-5 are the rings. The rings have an inner radius of 2.5 units; the outer radius is 3 units. The ratio of inner to outer ratio, and the general logic of the approach are to be found [here](http://sierra.nmsu.edu/morandi/CourseMaterials/OlympicRings.html). ``` i = Implicit Region; R1 = i[6.25 <= (x + 6.4)^2 + y^2 <= 9 , {x, y}]; R2 = i[6.25 <= x^2 + y^2 <= 9 , {x, y}]; R3 = i[6.25 <= (x - 6.4)^2 + y^2 <= 9 , {x, y}]; R4 = i[6.25 <= (x + 3.2)^2 + (y + 3)^2 <= 9 , {x, y}]; R5 = i[6.25 <= (x - 3.2)^2 + (y + 3)^2 <= 9 , {x, y}]; ``` ## Why we cannot simply print out the 5 rings without taking layers into account. If we plot these rings straightaway, they do not interlock. Notice that the yellow ring lies atop the blue and black rings; the green ring lies atop both the black and red rings. ``` Show[{RegionPlot[R1, PlotStyle -> Blue, BoundaryStyle -> Blue], RegionPlot[R2, PlotStyle -> Black, BoundaryStyle -> Black], RegionPlot[R3, PlotStyle -> Red, BoundaryStyle -> Red], RegionPlot[R4, PlotStyle -> Yellow, BoundaryStyle -> Yellow], RegionPlot[R5, PlotStyle -> Green, BoundaryStyle -> Green] }, PlotRange -> All, PerformanceGoal -> "Quality", ImageSize -> Large, AspectRatio -> 1/2, Frame -> False] ``` [![atop](https://i.stack.imgur.com/JNfzE.png)](https://i.stack.imgur.com/JNfzE.png) --- ## Flipping colors at 4 intersections of rings. Regions 6, 8, 10 and 12 are rectangles that serve to specify which intersection of two rings to focus on. Regions 7, 9, 11, and 13 are the "ring overlaps" where the ring on the bottom should be on top. ``` R6 = Rectangle[{-5, -1}, {-2, 1}]; R7 = RegionIntersection[R1, R4, R6]; R8 = Rectangle[{2, -1}, {4, 1}]; R9 = RegionIntersection[R2, R5, R8]; R10 = Rectangle[{-2, -3}, {2, -2}]; R11 = RegionIntersection[R2, R4, R10]; R12 = Rectangle[{5, -3}, {7, -2}]; R13 = RegionIntersection[R3, R5, R12]; Show[{RegionPlot[R1, PlotStyle -> Blue, BoundaryStyle -> Blue], RegionPlot[R2, PlotStyle -> Black, BoundaryStyle -> Black], RegionPlot[R3, PlotStyle -> Red, BoundaryStyle -> Red], RegionPlot[R4, PlotStyle -> Yellow, BoundaryStyle -> Yellow], RegionPlot[R5, PlotStyle -> Green, BoundaryStyle -> Green], RegionPlot[R7, PlotStyle -> Blue, BoundaryStyle -> Blue], RegionPlot[R9, PlotStyle -> Black, BoundaryStyle -> Black], RegionPlot[R11, PlotStyle -> Black, BoundaryStyle -> Black], RegionPlot[R13, PlotStyle -> Red, BoundaryStyle -> Red]}, PlotRange -> All, PerformanceGoal -> "Quality", ImageSize -> Large, AspectRatio -> 1/2, Frame -> False] ``` [![rings](https://i.stack.imgur.com/k04Zh.png)](https://i.stack.imgur.com/k04Zh.png) --- ## Which intersections had their colours flipped? The following highlights the intersection regions where colours were "flipped". This was accomplished by changing the `BoundaryStyle` of regions 7, 9, 11, and 13 to `White`. [![highlights](https://i.stack.imgur.com/J4W8m.png)](https://i.stack.imgur.com/J4W8m.png) [Answer] ### Javascript (three.js) - 910 bytes Given an html element, this function will create the rings as 3D objects and then render a still image to the element. Works in browsers that support WebGL. [FIDDLE](http://jsfiddle.net/XGundam05/5rYK4/) ``` function Logo(l){ var s, c, r; s = new THREE.Scene(); c = new THREE.PerspectiveCamera(45, 4/3, 1, 500); c.position.set(75,0,300); c.lookAt(new THREE.Vector3(0,0,0)); var rings = [ new THREE.Mesh(ring(), mat(0x0885c2)), new THREE.Mesh(ring(), mat(0xfbb132)), new THREE.Mesh(ring(), mat(0x000000)), new THREE.Mesh(ring(), mat(0x1c8b3c)), new THREE.Mesh(ring(), mat(0xed334e)) ]; for(var i = 0; i < rings.length; i++){ s.add(rings[i]); rings[i].position.set(i55-125,-(i%2)50,0); rings[i].rotation.set(0,(i%22-1).18,0,'xyz'); } r = new THREE.WebGLRenderer(); r.setSize(400, 300); l.appendChild(r.domElement); r.render(s, c); } function ring(){ return new THREE.TorusGeometry(50, 8, 16, 32); } function mat(color){ return new THREE.MeshBasicMaterial({color: color}); } ``` [Answer] # cat (10 bytes) It was so short that the website refused to upload it until I added this description. The logo represents Olympic Games. ``` $ $ $ $ $ ``` [Answer] ### C++ w/SFML (1003 incl. whitespace) Not small by any stretch of the imagination, but kept as terse-yet-readable as possible and still under 1k. ``` #include <SFML/Graphics.hpp> using namespace sf; int main() { CircleShape circles[5]; Color backcolor(255,255,255); Color colors[5] = { Color(0x0b,0x8e,0xd8), Color(0xf9,0xa9,0x1f), Color(0x23,0x1f,0x20), Color(0x00,0x9e,0x59), Color(0xee,0x20,0x49), }; for (int i = 0; i < 5; i++) { circles[i] = CircleShape(144, 60); circles[i].setPosition(15+160i, 46+160(i&1)); circles[i].setFillColor(Color::Transparent); circles[i].setOutlineColor(colors[i]); circles[i].setOutlineThickness(-16); } RenderWindow window(VideoMode(960, 540), L"Olympic Logo", Style::Close); while (window.isOpen()) { Event event; while (window.pollEvent(event)) if (event.type == Event::Closed) window.close(); window.clear(backcolor); for (int i = 0; i < 5; i++) window.draw(circles[i]); window.display(); } return 0; } ``` Edit: Updated colors based on @Peter Taylor's SVG submission. [Answer] ## Delphi ``` Canvas.Pen.Width := 10; Canvas.Brush.Style:=bsClear;//To prevent solid background Canvas.Pen.Color:=clBlue; Canvas.Ellipse(20,30,220,230); Canvas.Pen.Color:=clBlack; Canvas.Ellipse(240,30,440,230); Canvas.Pen.Color:=clRed; Canvas.Ellipse(460,30,660,230); Canvas.Pen.Color:=clYellow; Canvas.Ellipse(130,130,330,330); Canvas.Pen.Color:=clGreen; Canvas.Ellipse(350,130,550,330); ``` ### Result ![enter image description here](https://i.stack.imgur.com/pQHzs.png) [Answer] # SpecBAS Each ring is made up of an inner/outer circle, then flood-filled. Had to find the intersections manually and fill those individually (so you can still see some of the lines between them). ``` 1 INK 0: PAPER 15: CLS: LET r=50 2 FOR x=1 TO 3 3 CIRCLE x100,100,r: CIRCLE x100,100,r-10 4 IF x<3 THEN CIRCLE (x100)+50,150,r: CIRCLE (x100)+50,150,r-10 5 NEXT x 6 INK 0: FILL 165,130: FILL 195,145: FILL 200,55: FILL 215,145: FILL 245,105 7 INK 9: FILL 100,55: FILL 130,130: FILL 145,105 8 INK 10: FILL 270,135: FILL 295,145: FILL 300,55 9 INK 12: FILL 205,145: FILL 215,120: FILL 250,195: FILL 255,105: FILL 280,120 10 INK 14: FILL 105,145: FILL 110,125: FILL 150,195: FILL 155,105: FILL 190,130 ``` ![enter image description here](https://i.stack.imgur.com/30qsd.png) [Answer] made a solution based on a Java Swing GUI UltraGolfed edition (696 charas) ``` import java.awt.Color;import java.awt.Graphics;import javax.swing.JFrame;import javax.swing.JPanel;class A extends JFrame{public A(){JPanel j=new JPanel(){protected void paintComponent(Graphics g){;((java.awt.Graphics2D)g).setStroke(new java.awt.BasicStroke(3));g.setColor(new Color(0xb,0x8e,0xd8));g.drawOval(10, 10, 80, 80);g.setColor(new Color(0xf9,0xa9,0x1f));g.drawOval(50,40,80,80);g.setColor(new Color(0x23,0x1f,0x20));g.drawOval(90, 10, 80, 80);g.setColor(new Color(0,0x9e,0x59));g.drawOval(130,40,80,80);g.setColor(new Color(0xee,0x20,0x49));g.drawOval(170, 10, 80, 80);}};j.setBounds(0,0,600,400);setSize(600,400);add(j);}public static void main(String[]a){new A().setVisible(true);}} ``` Semiuncompressed one: (971) ``` import java.awt.Color; import java.awt.Graphics; import javax.swing.JFrame; import javax.swing.JPanel; class A extends JFrame { public A() { JPanel j = new JPanel(){ protected void paintComponent(Graphics g) {; ((java.awt.Graphics2D)g).setStroke(new java.awt.BasicStroke(3)); g.setColor(new Color(0xb,0x8e,0xd8)); g.drawOval(10, 10, 80, 80); g.setColor(new Color(0xf9,0xa9,0x1f)); g.drawOval(50,40,80,80); g.setColor(new Color(0x23,0x1f,0x20)); g.drawOval(90, 10, 80, 80); g.setColor(new Color(0,0x9e,0x59)); g.drawOval(130,40,80,80); g.setColor(new Color(0xee,0x20,0x49)); g.drawOval(170, 10, 80, 80);}}; j.setBounds(0,0,600,400); setSize(600,400); add(j); } public static void main(String[]a) { new A().setVisible(true); } } ``` [Answer] POWERSHELL , 869 code and output in screenshot ![PowerShell olympic logo](https://i.stack.imgur.com/qonot.png) ]
[Question] [ The Challenge Print a nice Christmas tree with it's own star at the top using the shortest code possible. The tree star is an asterisk (``) and the tree body is made out of `0` The tree must be 10 rows high. Every row should be properly indented in the way that the previous row are centered over the next one. Any given row must have 2 more 0s than the previous, except for the first one that is the star and the second, which has only one 0. The result is something like this: ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` Tie break for resizable height trees without software changes (except changing height parameter) Please, paste the resulting tree of your code too! --- ## Leaderboard ``` var QUESTION_ID=4114,OVERRIDE_USER=73772;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+)(?=[^\n\d<>](?:<(?:s>[^\n<>]<\/s>\|[^\n<>]+>)[^\n\d<>])<\/h\d>)/,OVERRIDE_REG=/^Override\sheader:\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> ``` [Answer] I know this doesn't comply with the spec, but I thought I'd try to add some diversity to the trees here by imitating [this classic ASCII art Christmas scene by Joan G. Stark](https://asciiart.website/joan/www.geocities.com/SoHo/7373/xmas.html#greetings). I didn't try to reproduce the whole picture — that would've been a bit too much — but just the tree, for which I present this 138-byte Perl program: ``` $_=join$/,qw'11\| 8\2_2/ 9(\o/) 5---2/1\2--- 10><',map(11-$_.A.AA x$_,2..11),'9\\|H\|/';s/\d+/$"x$&/eg,s/A/substr">>>@O<<<",rand 9,1/eg,say ``` And, of course, here's a sample of the output: ``` \| \ _ / (\o/) --- / \ --- >< >O><@ <><<>>< @><><>@<< @<O><@>>O OO@@O<<<<OO ><<>@><<>@<><>< >><O<>>><@>>><<O <><><<>@><O>><< O><><<@<>><O@>O><> O<><<><@O>>OOO<><<>O> \\|H\|/ ``` [Try it online!](https://tio.run/##HcrdCoIwGADQVxky8qdtn99ASLLR7rqJXmAwDCWMcuaMDHz2VnR1bs7QjrciBGp3V9f1FNjjFSMuZGOklUDKxDhIScE5l4BG/iSYq6yK2b0eEkROrdBCazJTy6QQiCmLS7McFoi3HkyzBhrNdAXthXnQ4J9nP42RUmqfnaqqithY9w0pGf5H/Q7h44apc70P/FiIHPMv "Perl 5 – Try It Online") The code uses the Perl 5.10+ `say` feature, and so needs to be run with the `-M5.010` (or `-E`) command line switch. (Actually, just replacing the `say` at the end with `print` would avoid that, at the cost of two more bytes and the loss of the newline after the last line of output.) Note that the bulk of the tree is randomly generated, so the placement of the ornaments will vary between runs. The angel, the stand and the top row of the tree are fixed, though. --- To keep this popular answer from being summarily deleted under [a policy instituted after it was posted](https://codegolf.meta.stackexchange.com/a/7990), here's a token spec-compliant solution as well (45 bytes, also Perl 5): ``` $_=$"x10 ."";say,s/ 0/00/,s/\?$/0/ while/ / ``` [Try it online!](https://tio.run/##K0gtyjH9/18l3lZFqcLQQEFPSUvJujixUqdYX8FA38BAH8iI0bJX0TfQVyjPyMxJ1VfQ////X35BSWZ@XvF/XV9TPQNDAwA "Perl 5 – Try It Online") Like the program above, this one also needs to be run on Perl 5.10+ with the `-M5.010` switch to enable the `say` feature. Obviously (this being a [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'") challenge) it produces the exact same boring output as all the other compliant entries, which I won't bother repeating here. (It's also trivially resizable by changing the number `10` to any other other value.) [Answer] ## Golfscript, 27 characters ``` " "9""9,{n\.4$>\.+)"0"}% ``` The resulting tree looks like this: ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` A version which uses the height parameter only once is one character longer: ``` 9." """@,{n\.4$>\.+)"0"}% ``` Reading the height from stdin (with input "10" to generate the example tree) takes the same amount of characters (28): ``` ~,)" """@{n\.4$>\.+)"0"}% ``` [Answer] ## GolfScript (33 chars) Fixed-height version: ``` ;8:^' '.''+\'0'+^{.(;'00'+}]n ``` Or for exactly the same length ``` ;8:^' '.''+n@'0'+^{.n\(;'00'+}* ``` The tree looks remarkably similar to everyone else's: ``` * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` Version which takes height from stdin: ``` ~((:^' '.''+\'0'+^{.(;'00'+}]n ``` The start of the previous line is one of the better smilies I've made in a "useful" GolfScript program. [Answer] # Shell script, 44 characters ``` printf %9c\\n \* 0\|sed ':x p;s/ 0/000/;tx d' ``` Prints this tree: ``` * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` [Answer] ### Ruby, 46 characters ``` puts" "8+?;9.times{\|i\|puts"%8s0"%(v=?0i)+v} ``` In order to change the height you would have to change both 8s and of course also the 9. The output of the program is as follows: ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` Edit: Inexcusably I omitted the output in the first submission. [Answer] ## Maple, 30 / 37 chars Inspired by [Mr.Wizard's Mathematica entry](https://codegolf.stackexchange.com/a/4139/3191), I present this 30-char Maple 12 command: ``` <``,('cat(0$2i+1)'$i=0..8)>; ``` Output: ``` [ * ] [ ] [ 0 ] [ ] [ 000 ] [ ] [ 00000 ] [ ] [ 0000000 ] [ ] [ 000000000 ] [ ] [ 00000000000 ] [ ] [ 0000000000000 ] [ ] [ 000000000000000 ] [ ] [00000000000000000] ``` I can also get rid of the brackets at the cost of seven more chars: ``` ``;for i in$0..8 do;cat(0$2i+1);od; ``` Output omitted — it looks just like above, only without the brackets. Unfortunately, I don't know any way to keep Maple from inserting blank lines between the output rows in text mode. It looks better in classic worksheet mode. I guess I could include a screenshot... ![screenshot](https://i.stack.imgur.com/KgjCf.png) (The screenshot shows an earlier 44-char version of the command, but I'm too lazy to retake it. The output is still the same.) Oh, and yes, the size is fully adjustable: just replace the 8 with n-2 for an n-row tree. With the first solution, going above 25 rows (or 10 in the GUI) requires also setting interface(rtablesize = n), though. (Ps. I thought I'd managed to [beat GolfScript](https://codegolf.stackexchange.com/a/4132/3191) with the latest version, [but alas...](https://codegolf.stackexchange.com/a/4185/3191)) [Answer] ### Perl, 42 chars ``` say$"x9,"";say$"x(9-$_),"00"x$_,0for 0..8 ``` Output: ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` The height of the tree can be changed between 1 and 11 rows by replacing the `8` at the end with values from `-1` to `9`. Going above 11 rows requires also increasing the two `9`s earlier in the code, which control how far from the left side of the screen the tree is indented. [Answer] # Groovy, 65 ``` (p={c,r->println' '(9-r)+(c(r2-1))})'',1;(1..9).each{p'0',it} ``` Surprisingly, the tree looks like this: ``` * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` [Answer] # PowerShell, 41 ``` " "8+"";0..8\|%{" "(8-$_)+"0"+"0"$_2} ``` Unsurprisingly, outputs the same tree as everyone else's :-p If you parametrize that 8, it will yield up to the size of your console, in, say, 48 characters: ``` " "($w=8)+"";0..$w\|%{" "($w-$_)+"0"+"0"$_2} ``` Or, as a full-blown script which takes an argument, 53 characters: ``` param($w)" "$w+"";0..$w\|%{" "($w-$_)+"0"+"0"$_2} ``` Called, it looks like: ``` PS>: Get-Tree.ps1 8 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` [Answer] ## Python 3: 62 characters ``` print(' '9+'',('\n'+' '(9-i)+'0'(i2+1)for i in range(9))) ``` Output: ``` * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` Note that this essentially beats @Ante's answer by 11 characters, because that answer, when converted to Python 3, uses 73 characters. Change each `9` to another value for a different height. [Answer] ## Python, 59 ``` print' '9+'' for i in range(9):print' '(9-i)+'0'(i2+1) ``` [Answer] ## Prolog: 183 or 186 ``` r(0,_,L,L). r(N,C,L,[C\|T]):-N>0,M is N-1,r(M,C,L,T). y(S,T,C):-r(T,C,[10],X),r(S,32,X,Y),atom_codes(A,Y),write(A). x(A,B):-A>0,y(A,B,48),C is A-1,D is B+2,x(C,D). x(N):-y(N,1,42),x(N,1). ``` Prints: ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 false. ``` Could be squeezed further for certain interpreters (e.g. using tab/1 on SWI) Invoke with x(N). Where N is the number of rows in the actual tree (excluding star). Giving it a fixed height would bring it down to 183 [Answer] C This is Wade Tandy's C version but modified a little bit: ``` ; int main( ){int i =-1,j=0,c =10;while(j ++<c){printf( " ");}{;printf( "");}while(++i<c ){for(j=-2;++j<c-i; )printf(" ");for(j=0; ++j<2i;){printf("0");} ;;; printf( "\n") ;}} ``` [Answer] ## Mathematica, 50 ``` MatrixForm@Prepend[Row/@Table[0,{n,9},{2n-1}],""] ``` [Answer] # Applesoft BASIC, 143 chars Since this question reminds me of a homework assignment I had back in high school (when they were teaching on an Apple //e): ``` 1INPUTH:X=(H2)-2:C=(X/2):S$="":O=0:GOSUB2:S$="0":FORO=0TOX-2STEP2:GOSUB2:NEXT:END 2FORS=0TOC-(O/2):?" ";:NEXT:FORI=0TOO:?S$;:NEXT:?"":RETURN ``` I used the JavaScript Applesoft BASIC found here: <http://www.calormen.com/applesoft/> OUTPUT:* ``` ?10 * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` [Answer] ## Prolog: 127 characters ``` p:-write(' '),h(1). h(L):-(L<10,nl,w(L,-8),h(L+1));!. w(L,N):-(N<9,N<L,(L>abs(N)->write('0');write(' ')),w(L,N+1));!. ``` Output: ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 true ``` Used `Prolog` because I was not able to beat the `Groovy` record without looking at his code :(. [Answer] # PostScript (with parameterised height), 114 characters ``` /h 9 def/b{{( )=print}repeat}def h -1 0{dup h eq{dup b()=}if dup b h sub neg 2 mul 1 add{(0)=print}repeat()=}for ``` Output: ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 0000000000000000000 ``` What, you wanted it to print out? [Answer] ## JavaScript (Rhino: 108, Node: 114, Webkit Dev Console: 119, jQuery Plugin: 132) Rhino is the shortest (at 108 characters) because (a) its `print` function has a short name and (b) it'll let you assign built-in functions into a shorter variable name. So: ``` h=10,p=print,m='0',a=Array(h-1),s=a.join(' ');p(s+'\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);} ``` Node.js* comes in a close second (at 114 chars) because its print function `console.log` has a longer name, but it'll let us assign that to a short variable as well: ``` h=10,p=console.log,m='0',a=Array(h-1),s=a.join(' ');p(s+'\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);} ``` However, the Webkit Dev Console* (and probably Firebug, too) thinks `p=console.log` is a bit too sneaky (when you try to call `p()`, it'll complain at you). So, we have to lengthen things out to 119 characters: ``` h=10,m='0',a=Array(h-1),s=a.join(' ');with(console){log(s+'\n'+s+m);while(h-->2){m+='00';a.pop();log(a.join(' ')+m);}} ``` (Interestingly, `with` only saves us a character). Finally... a jQuery plugin* (still tweetable at 132 characters!): ``` $.fn.xms=function(h){var m='0',w=2,l=['',m];while(w++<h)l.push(m+='00');$(this).css({textAlign:'center'}).html(l.join('\n<br/>'));} ``` And you can invoke it on the footer of this very page: `$('#footer').xms(3)` Of course, it doesn't have to be a plugin... since we'd probably have to use a JavaScript console to add it to a page and invoke it, we could've just done a snippet of jQuery: ``` h=10,m='0',w=2,l=['',m];while(w++<h)l.push(m+='00');$('#footer').css({textAlign:'center'}).html(l.join('\n<br/>')); ``` which weighs in at a more competitive 116 characters -- in fact, it beats out the other dev console implementation. But, then again, using jQuery and/or the browser's layout engine might be considered cheating. :) [Answer] ## C, 67 I know this is long over, but it's my first attempt at code golf, and I think I've got a pretty nice C solution. Interestingly, I came up with this independently of @Patrick's very similar solution. And yes, I won't win any ties with my hardcoded values ;) I'm quite pleased, anyway. ``` i;main(){for(;i<10;++i)printf("%s%0c\n",i?9-i:8,"",i2,i?32:42);} ``` ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 Press any key to continue . . . ``` [Answer] ### Oracle ``` select lpad('', 11) from dual union all select rpad(' ', 10 - level) \|\| rpad(' ', level 2, '0') from dual connect by level <= 9; * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 10 rows selected. ``` [Answer] # PHP, 106 characters 7 fewer than the previous: ``` <?php echo str_pad(' ',9)."\n";for($i=0;$i<9;$i++){echo str_pad("",9-$i).str_pad("",($i2)+1,"0")."\n";} ``` [Answer] # LOLCODE, 527 bytes ``` CAN HAS STDIO? HAI 1.2 IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 8 VISIBLE " "! IM OUTTA YR LOOP VISIBLE "" I HAS A SPACES SPACES R 8 I HAS A ZEROS ZEROS R 1 IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 9 IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN SPACES VISIBLE " "! IM OUTTA YR LOOP IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN ZEROS VISIBLE "0"! IM OUTTA YR LOOP VISIBLE "" SPACES R DIFF OF SPACES AN 1 ZEROS R SUM OF ZEROS AN 2 IM OUTTA YR LOOP KTHXBYE ``` [Try it online!](https://tio.run/##nVHBDoIwDL3vK54cPRjhpCczYIRGYIQNIl7VGwn/f8IxGAkhmmgPXdrXvtd2Xd89@udrGCJeIOUKSsckLyzlBP8QMMpBBdoKmZQl6rKcooZX0JQhlDqF4iK3GUNxYjDWkKIwE/Dg7UYKWWvNHQtb0L3HyIpyqJJHQrHpQWV4HHIXlVTMepP3f57obCf63BVs24Kxb54Is61WmhnXa/0nMy22lTl@k1mqPBsuV4spSSATlzD0vi1w11N1PsJTaNBg@zlXnd7CVgzDGw) ## Output: ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` [Answer] # Python, 70 characters Not so short, but recursive solution :-) ``` def a(s): print s if s<"0":a(s[1:]+"00") print" "8+"" a(" "8+"0") ``` Change 8's to set height. [Answer] # Javascript, 119 characters Outputs to firebug console ``` i=h=9;a=new Array(h);a[0]=a.join(' ');b=a.join('000');a[0]+='';while(i)a[i--]=b.substr(i,h+i);console.log(a.join('\n')) * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` [Answer] ## PHP 113 Figured i'd chime in with a php version: 113 chars (adjust `$h` to change the height, the number of lines includes the star): ``` $h=10;for($n=0;$n<$h;$n++){$i=$n>0?$n:1;$c=$n<1?"":"0";echo str_repeat(" ",$h-$i).str_repeat($c,($i2)-1)."\n";} ``` I tried to make it short, not readable and we already knew php can't compete on conciseness so this isn't going to win anything, still a fun little puzzle tho. output is as spec: ``` * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` [Answer] ## C, 77 ``` i;main(c){printf("%c\n",c,42);while(i<c)printf("%s%0d\n",c-i,"",i++2+1,0);} ``` Before reading the printf spec more carefully, I had this cute little number down to 138 chars: ``` #define x sprintf(b, #define y printf(b, i;main(c){char b[9]="%%%dc\n",t="%%%ds%%0%dd\n";x b,c);y 42);while(i<c)x t,c-i,i++2+1),y "",0);} ``` [Answer] ## Java, 192 (198 with param) `class V{public static void main(String[]a){int c=10,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2i;)s+="0";System.out.println(s);s="";}}}` Prints the requested tree: ``` * 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` For variable height, slightly longer: `class W{public static void main(String[]a){int c=a.length,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2i;)s+="0";System.out.println(s);s="";}}}` Length of command line argument list determines height (e. g. `java W a a a a a` will give height 5). (This is basically the Java version of Wade Tandy's C solution.) [Answer] # Vim, 18 bytes ``` 17i0<esc>qqYPxr q8@qa* ``` [Try it online](http://v.tryitonline.net/#code=MTdpMBtxcVlQeHIgcThAcWEq&input=) in the backwards-compatible V interpreter! Although this is a very similar approach as my V answer, this one is not non-competing since vim is crazy old. :) Explanation: ``` 17i0<esc> " Insert 17 '0's qq q " Start recording into register 'q' YP " Duplicate this line upwards x " Delete one character r " Replace this character with a space 8@q " Playback macro 'q' 8 times a* " Append an asterisk ``` [Answer] # Scala, 74 bytes ``` val h=10;println(" "h+"");for(i<-0 to h-2)println(" "(h-i)+"0"(i2+1)) ``` `h` - height of the tree Output ``` 0 000 00000 0000000 000000000 00000000000 0000000000000 000000000000000 00000000000000000 ``` [Answer] # C, 80 ``` i=9,k=10,j;main(F){while(i)putchar(++j<i?32:j<k?48-F6:(i-=!F,k+=!F,F=j=0,10));} ``` Initialize k to the tree height, i to k-1. F is first line flag. Given no argument, then F should be 1 upon entry. A slightly longer(81) version where f is non first line flag: ``` i=9,k=10,j,f;main(){while(i)putchar(++j<i?32:j<k?42+f6:(i-=f,k+=f,f=1,j=0,10));} ``` ]
[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/8859/edit). Closed 7 years ago. [Improve this question](/posts/8859/edit) In exactly 1024 characters, no more, no less: * Must print `Hello World`. * Must not use unnecessary whitespace. * Must not use comments. Judging should favor creativity and/or humor over simple obfuscation when voting up answers. --- The earliest I will select an answer is the 11th (Sunday) of November (2012). I'm seeing some awesome entries so far, can't wait to see what else people come up with. [Answer] ## C# (and without ‚ÄúHello World‚Äù anywhere) Code-golfed, so that obviously no unnecessary whitespace is used: ``` using System;using System.IO.Compression;using System.Runtime.Serialization;using System.Runtime.Serialization.Json;using System.Linq;using System.Net;using System.Text.RegularExpressions;class C{static void Main(){var g=WebRequest.Create("https://api.stackexchange.com/2.1/questions/8859?site=codegolf&filter=withbody");var r=(HttpWebResponse)g.GetResponse();if(r.StatusCode==HttpStatusCode.OK){var s=r.GetResponseStream();foreach(var a in r.ContentEncoding.ToLowerInvariant().Split(',').Reverse())switch(a){case"gzip":s=new GZipStream(s,CompressionMode.Decompress);break;case"deflate":s=new DeflateStream(s,CompressionMode.Decompress);break;default:throw new InvalidOperationException();}var d=new DataContractJsonSerializer(typeof(R));var q=(R)d.ReadObject(s);var e=new Regex("<code>([^<])</code>");var m=e.Match(q.I[0].B);Console.WriteLine(m.Groups[1].Value);}}}[DataContract]public class R{[DataMember(Name="items")]public I[]I{get;set;}}[DataContract]public class I{[DataMember(Name="body")]public string B{get;set;}} ``` Formatted for readability: ``` using System; using System.IO.Compression; using System.Runtime.Serialization; using System.Runtime.Serialization.Json; using System.Linq; using System.Net; using System.Text.RegularExpressions; class C { static void Main() { var g = WebRequest.Create("https://api.stackexchange.com/2.1/questions/8859?site=codegolf&filter=withbody"); var r = (HttpWebResponse)g.GetResponse(); if (r.StatusCode == HttpStatusCode.OK) { var s=r.GetResponseStream(); foreach (var a in r.ContentEncoding.ToLowerInvariant().Split(',').Reverse()) switch(a) { case "gzip": s = new GZipStream(s,CompressionMode.Decompress); break; case "deflate": s = new DeflateStream(s,CompressionMode.Decompress); break; default: throw new InvalidOperationException(); } var d = new DataContractJsonSerializer(typeof(R)); var q = (R)d.ReadObject(s); var e = new Regex("<code>([^<])</code>"); var m = e.Match(q.I[0].B); Console.WriteLine(m.Groups[1].Value); } } } [DataContract] public class R { [DataMember(Name="items")] public I[] I { get; set; } } [DataContract] public class I { [DataMember(Name="body")] public string B { get; set; } } ``` The program retrieves this question from Code Golf using Stack Exchange API, finds the first piece of text formatted as code (which, in case of this question, is the ‚ÄúHello World‚Äù text), and prints it out. [Answer] # brainfuck ``` >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++>+++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++[+++++<]>[.[-]>] ``` This is 1024 characters, excluding the whitespace I added to make a nice 64\16 block. The strategy is as follows: Fill the first few bytes with characters "Hello World", except each byte is 5 too small. This is done in all but the last 16 characters. The first byte is left blank in order to not have the pointer go out of bounds later. * Bring the pointer back to the start, adding 5 to each byte using `[+++++<]` * Go through the characters, print them and zero the byte using `>[.[-]>]` [Answer] # JavaScript (1024 bytes...) No unnecessary whitespace? What about unnecessary semicolons that JavaScript doesn't need at all? Let's add those semicolons to [make people like Crockford happy](http://figment.com/books/308826-Dangerous-Punctuation). ``` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;console.log('Hello World');;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ``` Yes, I'm aware that this is abuse of rules. [Answer] ## Shell :) ``` echo ' .@@@@......@@@@.@@@@@@@@@@@.@@.........@@...........@@@@@@@@.. ..@@@......@@@..@@.......@@..@..........@..........@........@@. ..@@@......@@@..@............@..........@.........@..........@@ ..@@@@@@@@@@@@..@@@@@@.......@..........@.........@..........@@ ..@@@@@@@@@@@@..@@@@@@.......@..........@.........@..........@@ ..@@@......@@@..@............@..........@.........@..........@@ ..@@@......@@@..@@.......@@..@@@@@@@@@@.@@@@@@@@@..@.......@@@. .@@@@......@@@@.@@@@@@@@@@@..@@@@@@@@@@.@@@@@@@@@...@@@@@@@@.. @@............@@@..@@@@@.....@@@@@@@.....@@........@@@@@@@@@@. .@@..........@@...@.....@.....@.....@@...@@.........@@.......@. ..@@........@@...@.......@....@.....@@...@@.........@@........@ ...@@..@@..@@...@.........@...@@@@@@.....@@.........@@........@ ....@@@.@@.@....@........@@...@@@@.@@....@@.........@@........@ ....@@...@@@....@.......@@....@.....@@...@@.........@@.......@ ...@@......@@....@.....@@.....@......@@..@@@....@@..@@@@...@@. ..@@.......@@@....@@@@@@....@@.......@..@@@@@@@@...@@@@@@@@@' ``` [Answer] # Mathematica 1024 chars ``` Graph[Partition[ Riffle[Characters[ StringTake[ElementData[][[2]], 3] <> StringTake[WordData["high", "Antonyms"][[2, 2, 1]], 2] <> FromCharacterCode[Power[2, 5]] <> StringTake[GraphData[][[Prime@705]], 2] <> StringTake[AstronomicalData["Planet"][[1]], {3}] <> "ld"], Rest@Characters[ StringTake[ElementData[][[2]], 3] <> StringTake[WordData["high", "Antonyms"][[2, 2, 1]], 2] <> FromCharacterCode[Power[2, 5]] <> StringTake[GraphData[][[Prime[705]]], 2] <> StringTake[AstronomicalData["Planet"][[1]], {3}] <> "ld"]], 2] /. {a_, b_} :> DirectedEdge[a, b], EdgeLabelStyle -> Power[2, 4], EdgeLabels -> (Partition[ Riffle[l = Characters[ StringTake[ElementData[][[2]], 3] <> StringTake[WordData["high", "Antonyms"][[2, 2, 1]], 1 + 1] <> FromCharacterCode[Sqrt[Sqrt[1048576]]] <> StringTake[GraphData[][[Prime[705]]], 2] <> StringTake[AstronomicalData["Planet"][[1]], {3}] <> "ld"], Rest@l], 2] /. {a_, b_} :> DirectedEdge[a, b]) + Power[{1, 8, 27, 64, 125, 216, 343, 512, 729, 1000}, 1/3] /. {Plus[a_, b_] :> Rule[b, a]}, VertexLabelStyle -> Directive[RGBColor[0, 0, 1], Large], VertexLabels -> "Name", ImagePadding -> Power[5, 2], ImageSize -> 2^25^27] ``` ![graph](https://i.stack.imgur.com/bolck.png) De-bowled (partially) For those who don't have access to Mathematica's curated data: ``` ElementData[][[2]] WordData["high", "Antonyms"][[2, 2, 1]] GraphData[][[Prime[705]]] AstronomicalData["Planet"][[1]] ``` > > "Helium" > > > "low" > > > "WongGraph" > > > "Mercury" > > > "Hel" (from "Helium") + "lo" (from "low") + " " (`FromCharacterCode[32]`) + "Wo" (from "WongGraph") + "r" (from "Mercury") + "ld" yields the string "Hello World". The string is split into characters, each of which becomes a vertex in the following graph: ``` Graph[{"H" \[DirectedEdge] "e", "e" \[DirectedEdge] "l", "l" \[DirectedEdge] "l", "l" \[DirectedEdge] "o", "o" \[DirectedEdge] " ", " " \[DirectedEdge] "W", "W" \[DirectedEdge] "o", "o" \[DirectedEdge] "r", "r" \[DirectedEdge] "l", "l" \[DirectedEdge] "d"}, EdgeLabelStyle -> 16, EdgeLabels -> {"H" \[DirectedEdge] "e" -> 1, "e" \[DirectedEdge] "l" -> 2, "l" \ [DirectedEdge] "l" -> 3, "l" \[DirectedEdge] "o" -> 4, "o" \[DirectedEdge] " " -> 5, " " \[DirectedEdge] "W" -> 6, "W" \[DirectedEdge] "o" -> 7, "o" \[DirectedEdge] "r" -> 8, "r" \[DirectedEdge] "l" -> 9, "l" \[DirectedEdge] "d" -> 10}, VertexLabelStyle -> Directive[Blue, Large], VertexLabels -> "Name", ImagePadding -> 25] ``` [Answer] ## C, 1024 characters Here's an adaptation of [my answer to another "Hello, world" question](https://codegolf.stackexchange.com/a/5193/3544): I'm not sure what's "unnecessary whitespace". I used spaces, indentation and line breaks to make code nicely formatted, but strictly speaking most of it is unnecessary. I did count the whitespace in the 1024 chars. EDIT: Changed to `return!` in the first line. Nicer this way, I think. ``` #include <stdio.h> int main(int argc, char argv, char envp) { return! putchar(-~-~-~-~-~-~-~-~-~-~! putchar(~-~-~-~-~-~-~-~- putchar(~-~-~-~-~-~- putchar(-~-~-~ putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ -~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ -~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- ~-~ putchar(-~-~-~ putchar( putchar(-~-~-~-~-~-~-~ putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ -~-~-~0)))))))))))); } ``` ## Another one - Python this time 1024 characters, 944 of them are whitespace, all necessary. ``` print 11'%c'%tuple(len(x)+8for x in' / / / / / / / / / / '.split('/')) ``` [Answer] ### GolfScript I had to modify the max length of scripts on <http://golfscript.apphb.com/> for this :) ``` 1))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ))))))))1))))))))))))))))))))))))))))))))))))))))))))))))))))))) )))))))))))))))))))))))))))))))))))))))))))))1)))))))))))))))))) )))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) )))))))))))))))))))))))))1)))))))))))))))))))))))))))))))))))))) )))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) )))))1)))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ))))))))))))))))))))))))))))))))))))))))))))))))))))' '1)))))))) )))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ))))))))))))))1))))))))))))))))))))))))))))))))))))))))))))))))) )))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))1)) )))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) )))))))))))))))))))))))))))))))))))))))))))))))1)))))))))))))))) )))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) )))))))))))))))))))))))))))1)))))))))))))))))))))))))))))))))))) ))))))))))))))))))))))))))))))))))))))))))))))))))))))){)}8]''+ ``` Run the program online [here](http://golfscript.apphb.com/?c=MSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpMSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkxKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkxKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkxKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSknICcxKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkxKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkxKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkxKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkxKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKXspfTgqXScnKw==&run=true). [Answer] ## Haskell ``` main=putStrLn hello_world where hello_world=show H++ello_world where ello_world=show E++llo_world where llo_world=show L++lo_world where lo_world=show L++o_world where o_world=show O++_world where _world=show ùûù++world where world=show W++orld where orld=show O++rld where rld=show R++ld where ld=show L++d where d=show D data Letter=H\|E\|L\|O\|ùûù\|W\|R\|D instance Show Letter where show H=["Hello, World!"!!0] show E=["Hello, World!"!!1] show L=["Hello, World!"!!2] show O=["Hello, World!"!!4] show ùûù=["Hello, World!"!!6] show W=["Hello, World!"!!7] show R=["Hello, World!"!!9] show D=["Hello, World!"!!11] main::IO() ``` 1024 characters, including the (necessary, Haskell is indentation-sensitive!) whitespace. (Though you could remove the line breaks entirely, but who wants an unreadable one-liner? Even now, it's hard enough to guess what this program does, what with the lack of comments...) [Answer] # Python 2 - 1024 ``` print''.join(chr(32if c[0]>"z"else """ Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Duis autem vel enum... """.count(c[0]+c[1])+99)for c in zip(' yddd~ doda','t iio~doliu')).title() ``` Writing this program was quite a tedious process, the length of the algorithm (first and last line) impacts the length of the dummy text (to meet the required total number of 1024 characters), which in turn impacts the count of certain substrings... And even worse: Some counts might just not occur with any substring, so I need to adjust the general bias 99, which impacts all other letters. But happily, a helper script is always quickly implemented. :) [Answer] Javascript, cut and paste into console (chrome browser of course) on this page to see the page disappear! ``` function pad_with_zeroes(number, length){ var my_string = '' + number; while (my_string.length < length){ my_string = '0' + my_string; } return my_string; } var code_tags = document.getElementsByTagName('code'); var hello_world = code_tags[0].innerHTML; var body_tags = document.getElementsByTagName('body'); var body = 'NULL'; body = body_tags[0]; var html_input = "<div id='div_that_holds_hello_world' style='font-size:50px; color:#987324; width: 900px; height: 900px; text-align: center;'><span id='hello_world_span'>" +hello_world+ "</span></div>"; body.innerHTML = html_input; var span = document.getElementById('hello_world_span'); var div = document.getElementById('div_that_holds_hello_world'); var j_c = 1; var i_c = 0; var setIn = setInterval(function(){ i_c++; if(i_c%2 == 0){ span.style.display = 'none'; }else{ span.style.display = 'block'; } if(i_c%50 != 0){ div.style.fontSize = j_c + 'px'; if(i_c < 1000000){ div.style.color = '#'+ pad_with_zeroes(i_c, 6); }else{ i_c = 0; } j_c++; }else{ j_c = 0; } }, 500); ``` [Answer] ## Javascript Lipsum Test with a regex: ``` "Hello World\|Ta what. Soft lad mardy bum that's champion. Tha knows chuffin' nora tha knows tha knows mardy bum shurrup. Where's tha bin. Any rooad ne'ermind. Is that thine cack-handed ah'll gi' thee a thick ear. Ah'll gi' thee a thick ear. Gerritetten tintintin ah'll learn thi shurrup chuffin' nora. Sup wi' 'im. Nah then soft southern pansy tintintin breadcake t'foot o' our stairs how much. Shu' thi gob be reet th'art nesh thee ah'll gi' thee a thick ear that's champion. Shu' thi gob t'foot o' our stairs tha daft apeth where's tha bin ah'll gi' thi summat to rooer abaht. Wacken thi sen up eeh eeh. Shu' thi gob tha what that's champion soft southern pansy ah'll learn thi a pint 'o mild. Appens as maybe gi' o'er nobbut a lad nobbut a lad.Big girl's blouse a pint 'o mild. Big girl's blouse ah'll learn thi. A pint 'o mild. How much ah'll gi' thi summat to rooer abaht michael palin nay lad. Gerritetten a pint 'o mild be reet nay lad. Nay lad how much ee by gum. 1234567I love feet so much.".match(/Hello World/)[0] ``` The regex: `.match(/Hello World/)[0]` [Answer] # Python Kinda cheap: ``` print"""Hello World"""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+"" ``` ]
[Question] [ It's one of [these](https://codegolf.stackexchange.com/questions/132558/i-double-the-source-you-double-the-output) again :D Your task, if you wish to accept it, is to write a program/function (without any uppercase letters) that outputs/returns its string input/argument. The tricky part is that if I convert your source code to uppercase, the output must be reversed. For simplicity, you can assume that the input is always a single line string containing only ASCII letters (`a-z`), digits (`0-9`), and spaces. You do not need to handle empty input. ## Example Let's say your source code is `abc` and its input is `hello`. If I write `ABC` instead and run it, the output must be `olleh`. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 1 byte ``` r ``` Try it online [lowercase](https://tio.run/##yy9OTMpM/f@/6P//4Pzc1OCSosy8dAA) or [uppercase](https://tio.run/##yy9OTMpM/f8/6P//4Pzc1OCSosy8dAA)! Finally a question which I (a dumb brain) can answer! Thanks for this easy, yet fun challenge! (I do feel great, even though it requires little effort to make an answer in 05AB1E.) ### Wait, how? ``` r # reverses the stack. (Which literally does not do anything since only the # implicit input is in the stack) R # actually reverses the top string of the stack (Which is the implicit input). # at the end, the input is automatically printed. ``` [Answer] # [Python 3](https://docs.python.org/3/), ~~61 50 49~~ 48 bytes -1 thanks to benrg! ``` r=-1;ʳ=1;ᵖʳᵢⁿᵗ(ᵢⁿᵖᵘᵗ()[::r]) ``` [lower-cased](https://tio.run/##K6gsycjPM/7/v8hW19D61GZbQ@uHW6ed2vxw66JHjfsfbp2uAWNNe7h1BoivGW1lVRSr@f9/RmpOTj4A "Python 3 – Try It Online") / [upper-cased](https://tio.run/##K6gsycjPM/7/P8hW19D61GZbQ@uHW6ed2vxw66JHjfsfbp2uAWNNe7h1BoivGW1lFRSr@f9/RmpOTj4A "Python 3 – Try It Online") This works because 1. [PEP-3131](https://www.python.org/dev/peps/pep-3131/) was implemented in Python 3.0; and 2. These are the minimal length Unicode characters with no upper-case version which also normalise under the Normalization Form Compatibility Composition ([NFKC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms)) transformation to the basic latin characters one would normally use - [TIO](https://tio.run/##XZAxa8MwEIX3/IrbJNGmYLLZaCpkCXTwWjIokoyPypK4ypTmz7tyncSRH5q@e0/cu/ib@uAP09RRGGD0qIOxRiUFOMRACXygQTm82l0XCDSgzy@OiYt6B1nYZSglsJYtYFYk9IkzYq9gvZGMif@RdbP7bYzREhdzSm8zepv4tqsFQUIgw7V4oJ8enYVq9Sy@FwlVgVyO6p44igKPGbv7QuUf3ZyR2aG8Wa/A2cfx9J57ue3@ZQ9X9njWhaz6mqZW7quGZNUsgdtRP@u6PYs/). Note that identifiers, like `r` and the function names `print` and `input`, may be written like this but not keywords, like `def` or `lambda`. (See the [upper-casing](https://tio.run/##K6gsycjPM/7/v6AoM69EIzOvoLREQ1OvtKAgtUhDU/P//yJbXUPrU5ttDa0fbp12avPDrYseNe5/uHW6Bow17eHWGSC@ZrSVVVGsJgA) of the code.) [Answer] # Python 3, 48 bytes ``` ᵖʳᵢⁿᵗ(ᵢⁿᵖᵘᵗ()[::b'b'[0]%3-1]) ``` [Lower: Try it online!](https://tio.run/##K6gsycjPM/7//@HWaac2P9y66FHj/odbp2vAWNMebp0B4mtGW1klqSepRxvEqhrrGsZq/v@fkZqTk69Qnl@UkwIA "Python 3 – Try It Online") ``` ᵖʳᵢⁿᵗ(ᵢⁿᵖᵘᵗ()[::B'B'[0]%3-1]) ``` [Upper: Try it online!](https://tio.run/##K6gsycjPM/7//@HWaac2P9y66FHj/odbp2vAWNMebp0B4mtGW1k5qTupRxvEqhrrGsZq/v@fkZqTk69Qnl@UkwIA "Python 3 – Try It Online") You can also verify that the [upper program is truly uppercase](https://tio.run/##K6gsycjPM/7/v6AoM69EQ@nh1mmnNj/cuuhR4/6HW6drwFjTHm6dAeJrRltZJaknqUcbxKoa6xrGairplRYUpBZpaGr@/w8A "Python 3 – Try It Online"). --- It's unlikely we can write a program for Python 3 just using ASCII - we have no `def`, no `lambda`, and no builtin function calls. Also, all the properties of existing builtin objects are lowercase so we can't access those either. So instead our strategy is to look for Unicode characters that: * Are not uppercase * NFKC normalise to the character we want * NFKC normalise to the character we want even after uppercasing The following code does exactly that. ``` from unicodedata import normalize for c in 'printinput': for i in range(0x10ffff): if not chr(i).isupper() and normalize('NFKC', chr(i)) == normalize('NFKC', chr(i).upper()) == c: print(chr(i)) break else: raise Exception('no') ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 1 [byte](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` ṛ ``` [lower-cased](https://tio.run/##y0rNyan8///hztn////PAHLyAQ "Jelly – Try It Online") / [upper-cased](https://tio.run/##y0rNyan8///hzln////PAHLyAQ "Jelly – Try It Online") ### How? ``` ṛ - Main Link: list of characters, S ṛ - right argument (implicitly S) - implicitly print Ṛ - Main Link: list of characters, S Ṛ - reverse - implicitly print ``` [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 10 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?") ([SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")) Anonymous tacit prefix function. ``` ⌽⍣('a'∊⎕a) ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HP3ke9izXUE9UfdXQ96puaqPk/7VHbhEe9fY@6mh/1rnnUu@XQeuNHbROBcsFBzkAyxMMz@H@agrpHak5Ovo5CeH5RToqiOgA "APL (Dyalog Unicode) – Try It Online") `⌽⍣(`…`)` apply reverse the following number of times: `'a'∊⎕a` is "a" a member of the uppercase alphabet? (0) ### Uppercased ``` ⌽⍣('A'∊⎕A) ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HP3ke9izXUHdUfdXQ96pvqqPk/7VHbhEe9fY@6mh/1rnnUu@XQeuNHbROBcsFBzkAyxMMz@H@agrpHak5Ovo5CeH5RToqiOgA "APL (Dyalog Unicode) – Try It Online") `⌽⍣(`…`)` apply reverse the following number of times: `'A'∊⎕A` is "a" a member of the uppercase Alphabet? (1) --- In Dyalog APL, `⎕A` is case-insensitive and always refers to the uppercase alphabet. [Answer] # [Perl 5](https://www.perl.org/) `-p`, ~~33~~, ~~25~~, 22 bytes Thank's to @DomHastings who also had the same idea ``` m;$_=/.(?{$\=$&.$\})^/ ``` uppercase ``` M;$_=/.(?{$\=$&.$\})^/ ``` [Try it online!](https://tio.run/##K0gtyjH9/9/XWiXeVl9Pw75aJcZWRU1PJaZWM07///@M1Jyc/H/5BSWZ@XnF/3ULAA "Perl 5 – Try It Online") [Answer] # [R](https://www.r-project.org/), 122 bytes ``` `\103`=`\162\145\166` `\151\156\164\124\157\125\164\1468`(c(`\165\164\1468\124\157\111\156\164`(`\163\143\141\156`(,"")))) ``` [try it online!](https://tio.run/##K/r/PyHG0MA4wRZImRnFGJqYAmmzBC4g19QQiM2AXJMYQyMgNjUH0qYQvomZRYJGsgZIE0IEocwQrjUBrMYYKA/CYOEEDR0lJU0g@J@ZV1Ba8h8A "R – Try It Online") [TRY IT ONLINE!](https://tio.run/##K/r/PyHG0MA4wRZImRnFGJqYAmmzBC4g19QQiM2AXJMYQyMgNjUH0qYQvomZRYKGswZIE0IEocwQrjUBrMYYKA/CYOEEDR0lJU0g@J@ZV1Ba8h8A "R – Try It Online") Includes only one letter, the lone `c` in the middle. The rest uses octal codes to get the equivalent of ``` C=rev intToUtf8(c(utf8ToInt(scan(,"")))) ``` With the lowercase `c`, the `c` makes no difference: we convert the input to integers, concatenate it with nothing, and convert back to characters. With an uppercase `C`, the integer vector in the middle gets reversed before being converted back. [Answer] # JavaScript (ES6), 46 bytes Takes and returns an array of characters. ### In lowercase ``` s=>s.map?s:s["\162\145\166\145\162\163\145"]() ``` [Try it online!](https://tio.run/##LcdNCoAgEEDhu7RRFw305yKwDlItxKwUc6KJrm8Frb73vL41mdMdVx5xtmlRiVRHsOujp5aGbCxkORZ18yp/35fV19nERTIYCYOFgCtf@AAAbLMhIJsEeHSRMyZEegA "JavaScript (Node.js) – Try It Online") ### In uppercase ``` S=>S.MAP?S:S["\162\145\166\145\162\163\145"]() ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/Y1i5Yz9cxwD7YKjhaKcbQzCjG0MQUSJtBaSDfzBjEVorV0PyfnJ9XnJ@TqpeTn66RphGtp6ennpGak5OvHqupl5Wfmaehrq6p@R8A "JavaScript (Node.js) – Try It Online") --- # JavaScript (ES6), ~~74~~ 73 bytes Saved 1 byte thanks to @Shaggy Takes and returns a string. ### In lowercase ``` s=>s.big?s:[...s]["\162\145\166\145\162\163\145"]()["\152\157\151\156"]`` ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1q5YLykz3b7YKlpPT684NlopxtDMKMbQxBRIm0FpIN/MGMRWitXQBKkwBYqYmgOxIRCbKcUmJPxPzs8rzs9J1cvJT9dI01DPSM3JyVfX1PwPAA "JavaScript (Node.js) – Try It Online") ### In uppercase ``` S=>S.BIG?S:[...S]["\162\145\166\145\162\163\145"]()["\152\157\151\156"]`` ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/Y1i5Yz8nT3T7YKlpPTy84NlopxtDMKMbQxBRIm0FpIN/MGMRWitXQBKkwBYqYmgOxIRCbKcUmJPxPzs8rzs9J1cvJT9dI01DPSM3JyVfX1PwPAA "JavaScript (Node.js) – Try It Online") [Answer] # [Haskell](https://www.haskell.org/), 38 bytes ``` _0(_1:_2)\|'a'<'_'=_0 _2++[_1] _0 _1=_1 ``` [Try it online! (lowercase)](https://tio.run/##y0gszk7Nyfn/P95AI97QKt5Is0Y9Ud1GPV7dNt5AId5IWzs63jCWC8Q2tI03/J@bmJlnm5lXklqUmFyiohBv8D8xpzglJ/c/AA "Haskell – Try It Online") ``` _0(_1:_2)\|'A'<'_'=_0 _2++[_1] _0 _1=_1 ``` [Try it online! (uppercase)](https://tio.run/##y0gszk7Nyfn/P95AI97QKt5Is0bdUd1GPV7dNt5AId5IWzs63jCWC8Q2tI03/J@bmJlnm5lXklqUmFyiohBv8D8xpzglJ/c/AA "Haskell – Try It Online") Haskell requires that any variable name beginning with a capital letter is constructor of a declared type. This basically means we can't have any identifiers that start with a letter. (I think the options we actually have are `LT`, `GT`, and `EQ` but I wasn't able to find a use for any of these.) Luckily it is possible to write haskell programs without letters. We can start variable names with `_` and we add numbers to the end to make it a valid name (certain symbols would work too). To detect that which mode we are in we use the fact that strings change and do a comparison between a changing and static string, `'a'<'_'` evaluates to `False` while `'A'<'_'` is true. [Answer] # [Ruby](https://www.ruby-lang.org/) `-p`, ~~51~~ ~~49~~ ~~47~~ 46 bytes Saved a byte by using a shorter lexicographical comparison taken from [@WheatWizard's Haskell answer](https://codegolf.stackexchange.com/a/211281/92901). ### Lowercase ``` ?a<?_&&(f=->_{/.$/?($_=$`;f[_+=$&]):$_=_})[''] ``` [Try it online!](https://tio.run/##KypNqvz/3z7Rxj5eTU0jzVbXLr5aX09F315DJd5WJcE6LTpe21ZFLVbTCsiPr9WMVleP/f8/IzUnJ/9ffkFJZn5e8X/dAgA "Ruby – Try It Online") `?a<?_` tests whether the character `a` is lexicographically less than the character `_`. The test returns `false`, short-circuiting the `&&` operator so that none of the remaining code is actually executed. The input is printed automatically thanks to the `-p` flag. ### Uppercase ``` ?A<?_&&(F=->_{/.$/?($_=$`;F[_+=$&]):$_=_})[''] ``` [Try it online!](https://tio.run/##KypNqvz/397Rxj5eTU3DzVbXLr5aX09F315DJd5WJcHaLTpe21ZFLVbTCsiPr9WMVleP/f8/IzUnJ/9ffkFJZn5e8X/dAgA "Ruby – Try It Online") Now we test whether `A` is lexicographically less than `_`. Here the comparison returns `true` so we proceed past `&&`. The code after `&&` defines and calls a recursive lambda that reverses the input, which (because of `-p`) has been stored in the predefined global variable `$_`: ``` (F=->_{ # define a lambda F with parameter _ /.$/?( # if $_ contains at least one character, match the last one, then $_=$`; # remove that character from $_ F[_+=$&] # recursively call F, appending that character to _ ):$_=_ # else set $_ to _, which now contains the full reversed input })[''] # call F, initialising _ to the empty string ``` Finally, `$_` (now containing the reversed input) is printed automatically thanks to the `-p` flag. [Answer] ## Windows NT Batch + coreutils, 28 bytes ``` @if %os:~9%==t (tac)else cat ``` Explanation: `%OS%` contains `Windows_NT` and the substring starting at position `9` is compared with the letter `t`. If the batch file is uppercased then the comparison succeeds and `tac` is invoked otherwise `cat` is invoked. [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 24 bytes ``` #[[i=1;i^2;;-i^2;;i^2]]& ``` [Try it online!](https://tio.run/##bcqxCsMgEADQ/T7jhEzp0K4SEEL2QtNJLFzlgkKiog6Fkm83pWu7vOltVB1vVL2ltgzYhNZ@OEv/uEh5@vrBmK4h3CwFDZN1UQm4Zh@qnuP0SplL8THoxajRUSZbORclzL8zx3tKnEcqrH5@178BHa9rxB6QnhZhN@0A "Wolfram Language (Mathematica) – Try It Online") `I` is the built-in symbol for the imaginary unit \$i\$. Its value cannot be overridden without `Unprotect`ing it first. [Answer] # [J](http://jsoftware.com/), 21 14 bytes ``` \|.^:({.\:'a_') ``` [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/a/TirDSq9WKs1BPj1TX/a3KlJmfkK6QpqGek5uTkq3NxpdvqKSAUOQIVcUHUpMPU/AcA "J – Try It Online") -7 bytes thanks to Adam! Taking inspiration from [Adam's APL answer](https://codegolf.stackexchange.com/a/211230/15469). ## how * `\|.^:` Reverse the following number of times... * `:({.\:'a_')` Grade down `\:` the string `a_` and take the first element `{.`. + "Grade down" returns a list of indexes for the string, sorted descending. Thus `\:'abc'` would return `2 1 0`, for example. + "Grade down" will thus return `0` for the string `a_`, and `1` for the string `A_`, since `_` is between `a` and `A` in the ascii alphabet. [Answer] # [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 9 bytes ``` ⌽⍣(<×'a') ``` [Try it online (both lower and upper)!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1HP3ke9izVsDk9XT1TXROY6qmtypRk@apvwqLfvUVfzofWmj9omPuqbGhzkDCRDPDyDudKMkKRN0KX/pxkqqCcmJasD1UEYAA "APL (Dyalog Extended) – Try It Online") In Extended, `×` (signum) on letters queries the letter case, giving -1 for lowercase and 1 for uppercase. Then `<` has implicit left arg of 0, so it tests if the right arg is positive (1) or not (0). Therefore, `<×'a'` evaluates to 0 and `<×'A'` evaluates to 1. [Answer] # [V (vim)](https://github.com/DJMcMayhem/V), 2 bytes ``` væ ``` [Try it online!](https://tio.run/##K/v/v@zwsv//PVJzcvJ1FMrzi3JSFAE "V (vim) – Try It Online") And uppercased: ``` Væ ``` [Try it online!](https://tio.run/##K/v/P@zwsv//PVJzcvJ1FMrzi3JSFAE "V (vim) – Try It Online") Hexdump: ``` 00000000: 76e6 v ``` ## How? `v` enters 'visual mode' and begins selecting characters. At first, only 1 character will be selected. Then `æ` reverses every character that is selected. Reversing only 1 character does nothing. But `V` will select every character on the current line, and then `æ` flips the whole line. [Answer] # [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 61 bytes ``` : f 'a 65 = if bounds 1- swap 1- -do i c@ emit 1 -loop then ; ``` [try it online!](https://tio.run/##XYy9CsIwGEV3n@LYxSlDBzsogqNv4JzmxwZiv5CkiE8f2006He65cLzkOqmX39DaBc9JM5y5ETyjLLMt9Iry0WmjskLA3HHvUOlRUSRRJzdzbaVDj6ZbG/WbHCYfVrObDxej8JQc7fHvaj8 "Forth (gforth) – Try It Online") [TRY IT ONLINE!](https://tio.run/##S8svKsnQTU8DUf//Wym4Kag7KpiZKtgqeLopOPmH@rkEKxjqKgSHOwaAaF0XfwVPBWcHBVdfzxAFQwVdH3//AIUQD1c/Bev/xUoKiUnJSgppCslFXEAOguWRmpOTrxCeX5SToggR/Q8A "Forth (gforth) – Try It Online") A challenge where the case insensitivity of Forth has a use ... except that you don't have a string reversal built-in, so you have to loop through the string itself in reverse. Almost all words in Forth are case-insensitive. The only case-sensitive part in the code is `'a` or `'A`, where the char's ASCII code (97 for `a`, 65 for `A`) is pushed to the stack. So we can compare it with a (trivially case-insensitive) numeric literal `65`. If they're equal, the string is printed in reverse. Otherwise, the string is returned as-is. [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 3 bytes ``` ṡ↔\| ``` and ``` Ṡ↔\| ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/pf/XDnwkdtU2pqH@7qVANyFsA4/6ES//8rpeXnJyUWKQEA "Brachylog – Try It Online") ``` ṡ↔ ṡ if input is a square matrix, Ṡ if input is a string, ↔ it is reversed \| otherwise return input unaltered ``` [Answer] ## PowerShell 7+, 56, 35 bytes ``` -join"$args"['a'[0]-97?99..0:0..99] # save as golf.ps1 and call .\golf.ps1 "string" # e.g. (running in anonymous function &{} for demo): PS C:\> &{-join"$args"['a'[0]-97?99..0:0..99]} '123 Alice' 123 Alice PS C:\> &{-JOIN"$ARGS"['A'[0]-97?99..0:0..99]} '123 Alice' ecilA 321 ``` With golfing suggestions from [mazzy](https://codegolf.stackexchange.com/users/80745/mazzy). Assuming the string is <= 100 characters. Change both the 99s to 1e5 notation for +2 bytes, much longer inputs, and much much slower code. ### old 56 byte version ``` &{$a="$args";(gv a).name[0]-97?-join$a[$a.length..0]:$a} e.g. PS C:\> &{$a="$args";(gv a).name[0]-97?-join$a[$a.length..0]:$a} "123 Alice" 123 Alice PS C:\> &{$A="$ARGS";(GV A).NAME[0]-97?-join$A[$A.LENGTH..0]:$A} "123 Alice" ecilA 321 ``` The parameters to the anonymous function `{}` appear in the automatic variable `$args` and get stored in variable `$a`. String quotes `"$args"` cast to a single string. PowerShell is indifferent about the case of variable names, command names, property names, operator names, etc. so all the code runs in either case. `gv` is `get-variable` which looks for the `a` variable, finds its `.Name` (`a` or `A` depending on the case of the script - case is preserved), gets character [0] which is `a` or `A` again but this time as a `[char]` type, subtracts 97 (lowercase `a` value in ASCII), and `? :` ternary operators whether that hit zero or non-zero, and either prints the original or reverse-indexes the characters and joins them into a reversed string. Printing is implicit. `&{}` runs the anonymous function. NB. TIO.Run only has PowerShell 5 or 6 at the time of writing, and ternary ?: is not in that version. [Answer] # [Pip](https://github.com/dloscutoff/pip), 6 bytes ``` [r_]@1 ``` This is a function solution. Since it relies on the recently added unary `R` operator, it doesn't work on TIO, but a similar 7-byte version does: ``` [rv_]@2 ``` [try it online!](https://tio.run/##K8gs@K/xP7qoLD7Wwei/kkdqTk6@jkJ4flFOiqKS5n8A "Pip – Try It Online") or [TRY IT ONLINE!](https://tio.run/##K8gs@K/xPzooLD7Wwei/kkdqTk6@jkJ4flFOiqKS5n8A) ### Explanation Lowercase: ``` [ ] Make a list containing r A random number between 0 and 1; _ The identity function @1 Get the item at index 1 (the identity function) ``` Uppercase: ``` [ ] Make a list containing R_ A function that reverses its argument @1 Get the item at index 1, with cyclical indexing (the function) ``` The TIO version is the same idea, but uses the `RV` operator for reverse. It therefore has three items in the lowercase list (including `v`, which is -1) and gets the function using index 2 instead of 1. [Answer] # [Raku](http://raku.org/), 28 bytes ``` {.?"{'flip'~^' '}"()\|\|$_} ``` [Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Ws9eqVo9LSezQL0uTl0BCNRrlTQ0a2pU4mvBitIVbBUgitx8PAMwFVkrFCdWKqjEa6hnpObk5CuU5xflpKhrKqTlFwFt0AEaYP0fAA "Perl 6 – Try It Online") * `$_` is the input to the function. Method calls lacking an explicit invocant are called on it. * `flip` is the method to reverse a string. * `$obj."name"()` is the syntax to call a method where the name is a string. The double quotes can contain interpolated values as usual. * `$obj.?method` means to call `method` on `$obj` if that method is defined for it, and otherwise return `Nil`. * `~^` is the stringy exclusive-or operator, which exclusive-ors the corresponding characters of its operands. Putting it all together, the uncapitalized program xors `flip` and a string containing four spaces, producing `FLIP`. That method is not defined for strings, so the `.?` method call returns `Nil`. Then `Nil \|\| $_` evaluates to the original string. When the source code is uppercased, `flip` becomes `FLIP`, which when xor-ed with the spaces becomes `flip`, which when called on the input string, reverses it. [Answer] # [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), 61 bytes ``` &lcase 'a' :f(r) output =input r output =reverse(input) end ``` [Try it online!](https://tio.run/##K87LT8rPMfn/n1MtJzmxOFVBPVGd0ypNo0iTizO/tKSgtETBNjMPSHEVwflFqWWpRcWpGmBxTa7UvJT//wE "SNOBOL4 (CSNOBOL4) – Try It Online") SNOBOL by default case-folds identifiers and labels (unless `&CASE` is set to `0` or the flag `-CASE 0` is used at the start of the program), so the only thing that really changes is the `'a' -> 'A'`, as SNOBOL uses case-sensitive pattern matching. Since `'A'` is not lowercase, it jumps to the label `R`, which reverses. [Answer] # [Klein](https://github.com/Wheatwizard/Klein) 0X0, 68 bytes Works in both 000 and 010 ## Lower case ``` "a`"1+-+?@ \ /!?: (0)?/!?:<@? >$:?!\?>:?!\$ / \ (/ \ )/ ``` [Try it online!](https://tio.run/##y85Jzcz7/18pMUHJUFtX295BAQxiuPQV7a1ALA0DTXsQ28bBnstOxcpeMcbeDkTGaCgo6HPFgFToKwApTf3////rJv83MDD4n1ickpudCwA "Klein – Try It Online") ## Upper case ``` "A`"1+-+?@ \ /!?: (0)?/!?:<@? >$:?!\?>:?!\\( / \ (/ \ )/ ``` [Try it online!](https://tio.run/##y85Jzcz7/1/JMUHJUFtX295BAQxiuPQV7a1ALA0DTXsQ28bBnstOxcpeMcbeDkTGaCgo6HPFgFToKwApTf3////rJv83MDD4n1ickpudCwA "Klein – Try It Online") --- Most of this is just a program that reverses the input, which is not exactly easy in Klein. ``` >:?!\?)0( :?!\?@ \ (//!?:<?/!?:$< $ / \( / ``` [Try it online!](https://tio.run/##y85Jzcz7/9/Oyl4xxl7TQEMBCMBsB64YBQUNfX1FeysbexCpYsMFklSI0VRQ0FeIAanU////v27yfwMDg/@JxSm52bkA "Klein – Try It Online") To do the condition we have the very simple ``` "a`"1+-+?@ ``` Which is an expression that is exactly zero, but becomes something else when `a` is capitalized. This is pretty much the exact method used by every other answer. The `?@` means that when it is zero it halts immediately (a cat program). Otherwise we continue execution to the reverse program bit. [Answer] # [JavaScript (V8)](https://v8.dev/), 46 44 then by tch: 37 bytes ``` $=([o,...a])=>o?o.sub?o+$(a):$(a)+o:a ``` [Try it online!](https://tio.run/##fYwxDsIwEAT7vMKyUpwVuBoFmRS8gQoh5TAXCHI4yzb@viE9otliNLNPKpRcnEPell11cmNl1VhbC2fZICJdjD3IIJje10G6Fsj063TSUx0xx3kBs28aLuRBT1arTq0vX@bklcQzernDBPrB3os2v2TMcgqB45ESg/mT1g8 "JavaScript (V8) – Try It Online") Thanks to [tsh](https://codegolf.stackexchange.com/users/44718/tsh) for saving 7 bytes!. Recursive function `$` takes a string and destructures it into the first character `o` and an array `a` of the remaining characters. If lower case, `o` has a property `sub` it returns the forward string `o+$(a)`. Otherwise, `O` has no property `SUB` and it returns the reverse string `$(A)+O`. The final iteration happens when `$` is called with and empty array so there is no `o`. Here it returns `a`, an empty array `[]` which acts as and empty string `""` in string addition. [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal) -v, 24 bytes ``` ternaryless"a""_"reverse ``` [Try it online!](https://tio.run/##S85ILErOT8z5/78ktSgvsagyJ7W4WClRSSleqSi1LLWoOPX/f2eYGt0yAA "Charcoal – Try It Online") In upper case: ``` TERNARYLESS"A""_"REVERSE ``` [Try it online!](https://tio.run/##S85ILErOT8z5/z/ENcjPMSjSxzU4WMlRSSleKcg1zDUo2PX/f2eYGt0yAA "Charcoal – Try It Online") Explanation: If `a` or `A` as appropriate is less than `_`, the ternary then reverses the implicit input, otherwise just takes implicit input. The result is then implicitly printed. [Answer] # [Japt](https://github.com/ETHproductions/japt), 1 [byte](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) ## Lowercase ``` ô ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=9A&input=ImFiY2RlZiI) Partitions the input at falsey characters, but there's no such thing as a falsey character in JavaScript. ## Uppercase ``` Ô ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=1A&input=ImFiY2RlZiI) The shortcut for `w<space>`, Japt's built-in for reversing. [Answer] # [Coconut](http://coconut-lang.org/), 21 bytes ``` _->_[::('a'>'_')2-1] ``` [Try it online!](https://tio.run/##S85Pzs8rLfmfZhvzP17XLj7aykpDPVHdTj1eXVPLSNcw9r96RmpOTr66Qo2dQhqIKCjKzCv5DwA "Coconut – Try It Online") [Try it uppercased!](https://tio.run/##S85Pzs8rLfmfZhvzP17XLj7aykpD3VHdTj1eXVPLSNcw9r96RmpOTr66Qo2dQhqIKCjKzCv5DwA "Coconut – Try It Online") [Answer] # [Keg](https://github.com/JonoCode9374/Keg), 9 bytes ``` ?r\{9-=[^ ``` [try it online!](https://tio.run/##y05N///fviim2lLXNjru/3/HpGQA "Keg – Try It Online") [TRY IT ONLINE!](https://tio.run/##y05N///fviim2lLXNjru/3/HpGQA "Keg – Try It Online") Somehow, by making the answer valid, I saved bytes. [Answer] # [MAWP](https://esolangs.org/wiki/MAWP), 19 bytes ``` %\|11a{%%0~}<%0/>[;] ``` [try it!](https://8dion8.github.io/MAWP/v1.1?code=%25%7C11a%7B%25%250%7E%7D%3C%250%2F%3E%5B%3B%5D&input=Hello) or [TRY IT!](https://8dion8.github.io/MAWP/v1.1?code=%25%7C11A%7B%25%250%7E%7D%3C%250%2F%3E%5B%3B%5D&input=Hello) MAWP ignores lowercase letters, so this answer uses a conditional to check if subtraction has happened or not, and reverses based on it. [Answer] # [oK](https://github.com/JohnEarnest/oK), 13 bytes ``` .:9+237!"!g" ``` [Try it online!](https://tio.run/##y9bNz/7/P81Kz8pS28hYy1xRSTFdicsNme@uxMWlkaaUWpGYW5CTqsSl4KbkGuHoG@DjqqT5/z8A "K (oK) – Try It Online") Explanation: ``` "!g" /magic string 9+237! /9 + 23 (ascii value mod 7) .: /eval ascii values as a string ``` When the input is `"!g"` it becomes `"\|\|"` which is evaluated as reversing twice. When the input is `"!G"` it becomes `"\| "` which is evaluated as reversing once. ## [oK repl](https://johnearnest.github.io/ok), 10 bytes I'm going to say that this one doesn't count, because it relies on the fact that the oK repl works in mysterious ways. ``` .:4*54!"u" ``` [Try it in repl!](http://johnearnest.github.io/ok/?run=%20f%3A.%3A4%2a54%21%22u%22%3BF%3A.%3A4%2a54%21%22U%22%3B%28f%22example%22%3BF%22EXAMPLE%22%29 "oK repl") When the input is `"u"` it becomes `"$"` which evaluates as "string of expression". In the repl it is a noop when applied to strings. When the input is `"U"` it becomes `"\|"` which evaluates as reversing. [Answer] # Excel VBA, 58 bytes Lowercase: ``` sub r(s) if asc("a")=65then s=strreverse(s) [a1]=s end sub ``` Uppercase: ``` SUB R(S) IF ASC("A")=65THEN S=STRREVERSE(S) [A1]=S END SUB ``` Output is to the cell `A1` of the currently active sheet (if this is in a module) or the parent sheet (if this is in a sheet object). I'm a little concerned this doesn't comply with the spec, though, because VBA auto-formats much of the code once it's input: ``` Sub r(s) If Asc("a") = 65 Then s = StrReverse(s) [a1] = s End Sub ``` Of course, the standard has been to not consider the extra formatting in the byte count so I presume we can also ignore the capitalization. Really, I'm more worried about the answer being too straightforward to be interesting rather than that technicality. ]
[Question] [ # The Challenge It's quite simple really, sort a list of numbers. # Details You must sort a list of numbers in ascending order, without using any built-in sorting functions/libraries/etc (i.e. `list.sort()` in Python). Input/output can be done in any method you choose, as long as it is human readable. Standard loopholes are disallowed as always. Shortest code in bytes wins. You must explain/list what sort method you used (Bubble, Insertion, Selection, etc.) Input will not contain duplicates. # Sample Input/Output Input: `99,-2,53,4,67,55,23,43,88,-22,36,45` Output: `-22,-2,4,23,36,43,45,53,55,67,88,99` Note: A near direct opposite of [Sort a List of Numbers](https://codegolf.stackexchange.com/questions/428/sort-a-list-of-numbers) [Answer] # [05AB1E](http://github.com/Adriandmen/05AB1E), 2 bytes Code: ``` œß ``` Same algorithm as the [Jelly answer](https://codegolf.stackexchange.com/a/77842/34388). Computes all permutations of the input and pops out the smallest one. [Try it online!](http://05ab1e.tryitonline.net/#code=xZPDnw&input=Wzk5LC0yLDUzLDQsNjcsNTUsMjMsNDNd) --- A more efficient method is: ``` E[ß,Ž ``` Performs selection sort. Uses CP-1252 encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=RVvDnyzFvQ&input=OTksLTIsNTMsNCw2Nyw1NSwyMyw0Myw4OCwtMjIsMzYsNDU) [Answer] # Jelly, 3 bytes ``` Œ!Ṃ ``` This generates all permutations of the input list, then selects the lexographically smallest permutation. Very efficient. Credits to @Adnan who had the same idea independently. [Try it online!](http://jelly.tryitonline.net/#code=xZIh4bmC&input=&args=OTksLTIsNTMsNCw2Nyw1NSwyMyw0Mw) --- # Jelly, 4 bytes ``` ṂrṀf ``` This builds the range from the minimum of the list to the maximum of the list, then discards the range elements not present in the original list. This is technically a bucket sort, with very small buckets. I'm not aware of a name for this specific variant. [Try it online!](http://jelly.tryitonline.net/#code=4bmCcuG5gGY&input=&args=OTksLTIsNTMsNCw2Nyw1NSwyMyw0Myw4OCwtMjIsMzYsNDU) ### How it works ``` ṂrṀf Main link. Argument: A (list/comma-separated string) Ṃ Compute the minimum of A. Ṁ Compute the maximum of A. r Yield the inclusive range from the minimum to the maximum. f Filter the range by presence in A. ``` [Answer] # Python, 46 45 bytes ``` lambda l:[l.pop(l.index(min(l)))for _ in 1l] ``` Simple selection sort. [Answer] # x86-16 machine code (BubbleSort int8\_t), ~~20~~ 19 bytes # x86-64/32 machine code (JumpDownSort) ~~21~~ 19 bytes Changelog: Thanks to @ped7g for the `lodsb`/`cmp [si],al` idea, and putting that together with a pointer increment / reset that I'd been looking at. Not needing `al`/`ah` lets us use nearly the same code for larger integers. * New (but related) algorithm, many implementation changes: Bubbly SelectionSort allows a smaller x86-64 implementation for bytes or dwords; break-even on x86-16 (bytes or words). Also avoids the bug on size=1 that my BubbleSort has. See below. * It turns out that my Bubbly Selection Sort with swaps every time you find a new min is already a known algorithm, JumpDown Sort. It's mentioned in [Bubble Sort: An Archaeological Algorithmic Analysis](https://users.cs.duke.edu/%7Eola/papers/bubble.pdf) (i.e. how did Bubble Sort become popular [despite sucking](https://stackoverflow.com/questions/61997897/why-bubble-sort-is-not-efficient) in general for speed). --- Sorts 8-bit signed integers in-place. (Unsigned is the same code size, just change the `jge` to a `jae`). Duplicates are not a problem. We swap using a 16-bit rotate by 8 (with a memory destination). [Bubble Sort](https://en.wikipedia.org/wiki/Bubble_sort#Optimizing_bubble_sort) sucks for performance, but I've read that it's one of the smallest to implement in machine code. This seems especially true when there are special tricks for swapping adjacent elements. This is pretty much its only advantage, but sometimes (in real life embedded systems) that's enough advantage to use it for very short lists. I omitted the early termination on no swaps. I used Wikipedia's "optimized" BubbleSort loop which avoids looking at the last `n − 1` items when running for the `n`-th time, so the outer loop counter is the upper bound for the inner loop. NASM listing (`nasm -l /dev/stdout`), or [plain source](https://pastebin.com/0VMzdUjj) ``` 2 address 16-bit bubblesort16_v2: 3 machine ;; inputs: pointer in ds:si, size in in cx 4 code ;; requires: DF=0 (cld) 5 bytes ;; clobbers: al, cx=0 6 7 00000000 49 dec cx ; cx = max valid index. (Inner loop stops 1 before cx, because it loads i and i+1). 8 .outer: ; do{ 9 00000001 51 push cx ; cx = inner loop counter = i=max_unsorted_idx 10 .inner: ; do{ 11 00000002 AC lodsb ; al = p++ 12 00000003 3804 cmp [si],al ; compare with p (new one) 13 00000005 7D04 jge .noswap 14 00000007 C144FF08 rol word [si-1], 8 ; swap 15 .noswap: 16 0000000B E2F5 loop .inner ; } while(i < size); 17 0000000D 59 pop cx ; cx = outer loop counter 18 0000000E 29CE sub si,cx ; reset pointer to start of array 19 00000010 E2EF loop .outer ; } while(--size); 20 00000012 C3 ret 22 00000013 size = 0x13 = 19 bytes. ``` push/pop of `cx` around the inner loop means it runs with `cx` = outer\_cx down to 0. Note that `rol r/m16, imm8` is not an 8086 instruction, it was added later (186 or 286), but this isn't trying to be 8086 code, just 16-bit x86. If SSE4.1 `phminposuw` would help, I'd use it. A 32-bit version of this (still operating on 8-bit integers but with 32-bit pointers / counters) is 20 bytes (operand-size prefix on `rol word [esi-1], 8`) Bug: size=1 is treated as size=65536, because nothing stops us from entering the outer do/while with cx=0. (You'd normally use `jcxz` for that.) But fortunately the 19-byte JumpDown Sort is 19 bytes and doesn't have that problem. --- Original x86-16 20 byte version (without Ped7g's idea). Omitted to save space, see the [edit history](https://codegolf.stackexchange.com/revisions/149038/5) for it with a description. --- Performance Partially-overlapping store/reload (in memory-destination rotate) causes a store-forwarding stall on modern x86 CPUs (except in-order Atom). When a high value is bubbling upwards, this extra latency is part of a loop-carried dependency chain. Store/reload sucks in the first place (like 5 cycle store-forwarding latency on Haswell), but a forwarding stall brings it up to more like 13 cycles. Out-of-order execution will have trouble hiding this. See also: [Stack Overflow: bubble sort for sorting string](https://stackoverflow.com/questions/26318043/assembly-bubble-sort-for-sorting-string/26324630#26324630) for a version of this with a similar implementation, but with an early-out when no swaps are needed. It uses `xchg al, ah` / `mov [si], ax` for swapping, which is 1 byte longer and causes a partial-register stall on some CPUs. (But it may still be better than memory-dst rotate, which needs to load the value again). My comment there has some suggestions... --- # x86-64 / x86-32 JumpDown Sort, 19 bytes (sorts int32\_t) Callable from C using the x86-64 System V calling convention as `int bubblyselectionsort_int32(int dummy, int array, int dummy, unsigned long size);` (return value = max(array[])). This is <https://en.wikipedia.org/wiki/Selection_sort>, but instead of remembering the position of the min element, swap the current candidate into the array. Once you've found the min(unsorted\_region), store it to the end of the sorted region, like normal Selection Sort. This grows the sorted region by one. (In the code, `rsi` points to one past the end of the sorted region; `lodsd` advances it and `mov [rsi-4], eax` stores the min back into it.) The name Jump Down Sort is used in [Bubble Sort: An Archaeological Algorithmic Analysis](https://users.cs.duke.edu/%7Eola/papers/bubble.pdf). I guess my sort is really a Jump Up sort, because high elements jump upwards, leaving the bottom sorted, not the end. This exchange design leads to the unsorted part of the array ending up in mostly reverse-sorted order, leading to lots of swaps later on. (Because you start with a large candidate, and keep seeing lower and lower candidates, so you keep swapping.) I called it "bubbly" even though it moves elements the other direction. The way it moves elements is also a little bit like a backwards insertion-sort. To watch it in action, use GDB's `display (int[12])buf`, set a breakpoint on the inner `loop` instruction, and use `c` (continue). Press return to repeat. (The "display" command gets GDB to print the whole array state every time we hit the breakpoint). `xchg` with mem has an implicit `lock` prefix which makes this extra slow. Probably about an order of magnitude slower than an efficient load/store swap; `xchg m,r` is one per 23c throughput on Skylake, but load / store / mov with a tmp reg for an efficient swap(reg, mem) can shift one element per clock. It might be a worse ratio on an AMD CPU where the `loop` instruction is fast and wouldn't bottleneck the inner loop as much, but branch misses will still be a big bottleneck because swaps are common (and become more common as the unsorted region gets smaller). ``` 2 Address ;; hybrib Bubble Selection sort 3 machine bubblyselectionsort_int32: ;; working, 19 bytes. Same size for int32 or int8 4 code ;; input: pointer in rsi, count in rcx 5 bytes ;; returns: eax = max 6 7 ;dec ecx ; we avoid this by doing edi=esi before* lodsb, so we do redundant compares 8 ; This lets us (re)enter the inner loop even for 1 element remaining. 9 .outer: 10 ; rsi pointing at the element that will receive min([rsi]..[rsi+rcx]) 11 00000000 56 push rsi 12 00000001 5F pop rdi 13 ;mov edi, esi ; rdi = min-search pointer 14 00000002 AD lodsd 16 00000003 51 push rcx ; rcx = inner counter 17 .inner: ; do { 18 ; rdi points at next element to check 19 ; eax = candidate min 20 00000004 AF scasd ; cmp eax, [rdi++] 21 00000005 7E03 jle .notmin 22 00000007 8747FC xchg [rdi-4], eax ; exchange with new min. 23 .notmin: 24 0000000A E2F8 loop .inner ; } while(--inner); 26 ; swap min-position with sorted position 27 ; eax = min. If it's not [rsi-4], then [rsi-4] was exchanged into the array somewhere 28 0000000C 8946FC mov [rsi-4], eax 29 0000000F 59 pop rcx ; rcx = outer loop counter = unsorted elements left 30 00000010 E2EE loop .outer ; } while(--unsorted); 32 00000012 C3 ret 34 00000013 13 .size: db $ - bubblyselectionsort_int32 0x13 = 19 bytes long ``` Same code size for `int8_t`: use `lodsb` / `scasb`, `AL`, and change the `[rsi/rdi-4]` to `-1`. The same machine-code works in 32-bit mode for 8/32-bit elements. 16-bit mode for 8/16-bit elements needs to be re-built with the offsets changed (and 16-bit addressing modes use a different encoding). But still 19 bytes for all. It avoids the initial `dec ecx` by comparing with the element it just loaded before moving on. On the last iteration of the outer loop, it loads the last element, checks if it's less than itself, then is done. This allows it to work with size=1, where my BubbleSort fails (treats it as size = 65536). I tested this version (in GDB) using the this caller: [Try it online!](https://tio.run/##dVVLb@M2EL7rV8yhwNobSk382thGDs1hgZyzt0UQUOLYYiORrkjFcov@9nQ4lGxlmxhIJM7rm/lmOJLOYZ1Xp9RIV7@9be8ffjzCapEA/bZbKE95o3O4b/O8QnjECguvrQFnG5/kQXpygzDInrXx89kmOh9t86LNXsDNGvKTR5cBPMoawem/EXa2AbaG@HI7YGpzaP0GDpaEGFTQOC2gsK3xfCq6wbRB3zbGbQBlB3dQyy6JKoUFABYdXH6UD4J8tVqBL7WjjEARxB5Q6Tt0Gr7mSDnhV6iscrmgGoOHsoSiWqMkoRe2PsgGXQKf/LbwI8Su0DtoHUwanCJX4Uuk3A29VdYeAF/RMAM3QPTVZEMotdSGEsqSzLbks4mlhOojGSFZ6TnU4ORLEhx1VZF7gfoVodZm8pNcnrIsPK6IracpRzq0rqQHCeOR0ghHFY/b2r6GJ7EhINDRgysdiNUmdSibohzawj6BKJW8Cz6mfMvHu75u7h85ZnzcfEAdUf1PcoFlJBcqNtj5S8kWihKLl94ydr6QRmklPdfPGldIpz4AKepD8BHwkzCurp7Y@E8absiM9YN3V5R7egSbdPEkGIXRSCHNHolzX1Jex4CXJWfnTc9L4DYWekH@F46lrnCSpqyYbvtZBXeUB6b4YJ3m68XRw31CBYPwXb0BFeBhB9p/cUDYEJrNqdJ4mOEER@nOOatwyyyPj2waeSKAGo8lNsih@/6f4xDQaE6aX@5S7CzPaSy3by8JW9Nn3ncsXIedHxMT3T4gZnAduKH7nSRZWBcbUDn8Bil8unSSN9cvp4wGQSbbvN3xlJHjjHaQgKWAdE5v397pWML6awEzhpWV3hu4WfFBKUhJefkLKdNsOkJ6lVWLkX/aCx7sjvLbxU6dIRSs1yKdieVcLIJArL6J5VLM6DgXt7ekmon5SiyWychlbE9mwYZ82Cz4U8RZcE7QqODFkPTCmxX/amESFUzYbgq/w@JczOJ6vQp1XM8WVHP3/fv4f@zI@/JoaKhxL7yv6L2WL7TC2wbjejRfPKmlCsPABNAgKJckybkdnq7v/3ndVzaXFTw7T8wl8bG5TCKGnT@QGSVFJ841cp7jGkd2eccbLI5QIWk5fjo0cZbjVyR8Pmh81@vk11iyG0YVO@0nZDfNRjZhm9zwmWIC0Xh7Pb4q81maaw9/3D@AO7lnDjEV/HV04Xu2WrC@sIoupiNSqypL3v4D "Assembly (nasm, x64, Linux) – Try It Online"). You can run this it on TIO, but of course no debugger or printing. Still, the `_start` that calls it exits with exit-status = largest element = 99, so you can see it works. [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), ~~12~~ 7 bytes ``` p.'(s>) ``` This uses permutation sort, which is obviously terrible, but hey it's shorter than Pyth! ### Explanation ``` p. Unifies the output with a permutation of the input '( ) True if what's inside the parentheses cannot be proven, else backtrack and try with another permutation of the input. s Take an ordered subset from the output > True if the first element is bigger than the second (hence not sorted) We don't need to check that the subset is 2 elements long because > will be false for inputs that are not 2 elements long anyway ``` [Answer] # Oracle SQL 11.2, 205 bytes ``` WITH s AS(SELECT COLUMN_VALUE\|\|''e FROM XMLTABLE(('"'\|\|REPLACE(:1,',','","')\|\|'"'))),v(p,f)AS(SELECT e,e FROM s UNION ALL SELECT p\|\|','\|\|e,e FROM v,s WHERE e+0>f)SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1); ``` Un-golfed ``` WITH s AS -- Split the string using ',' as separator ( -- \|\|'' cast the xml type to varchar SELECT COLUMN_VALUE\|\|''e FROM XMLTABLE(('"'\|\|REPLACE(:1,',','","')\|\|'"')) ), v(p,f) AS -- Recursive view : p = sorted string, f last number added ( SELECT e,e FROM s -- use each number as seed UNION ALL -- only add a number if it is > the last added SELECT p\|\|','\|\|e,e FROM v,s WHERE e+0>f -- +0 is needed to compare int and not strings ) -- The valid string has the same length as the input SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1) ``` As for what sort method it is, I have no idea, `ORDER BY` made sure I forgot them. [Answer] ## Haskell, 38 bytes ``` h%t\|(a,b)<-span(<h)t=a++h:b foldr(%)[] ``` The binary function `%` insert a new element `h` into a sorted list `t` by partitioning `t` into a prefix `a` of elements `<h` and a suffix `b` of elements `>h`, and sticks in `h` between them. The operation `foldr(%)[]` then builds up a sorted list from empty by repeatedly inserting elements from the input list. This is one byte shorter than the direct recursive implementation ``` f(h:t)\|(a,b)<-span(<h)$f t=a++h:b f x=x ``` Another strategy for 41 bytes: ``` f[]=[] f l\|x<-minimum l=x:f(filter(/=x)l) ``` [Answer] ## JavaScript (ES6), 51 bytes ``` a=>a.map(_=>m=Math.min(...a.filter(e=>e>m)),m=-1/0) ``` Each loop finds the smallest number that hasn't been found so far. [Answer] ## Python 2, 34 bytes ``` def f(s):m=min(s);print m;f(s-{m}) ``` Takes input as a set, printing its elements in increasing order, terminating with error. A clean termination can be done in 41 bytes: ``` def f(s): if s:m=min(s);print m;f(s-{m}) ``` or ``` l=input() while l:m=min(l);print m;l-={m} ``` The input can be take as a list for 39 bytes, or 38 bytes in Python 3.5: ``` def f(l):m=min(l);print m;f(set(l)-{m}) def f(l):m=min(l);print(m);f({l}-{m}) ``` [Answer] ## Haskell, ~~42~~ ~~41~~ 38 bytes ``` f u=filter(`elem`u)[(minBound::Int)..] ``` Loops through all integers (signed 64bit, on my machine) and keeps those that are in `u`. Of course it doesn't finish in reasonable time. The previous version looped through `[minimum u..maximum u]` which has the same worst case running time. Edit: @xnor saved a byte. Thanks! [Answer] # C, 72 bytes ``` i,j;a(intl,int n){for(i=0;i=i?:--n;j>l[n]?l[i]=l[n],l[n]=j:0)j=l[--i];} ``` Bubblesort. The first argument is a pointer to the array, the second argument is the length of the array. Works with gcc. [Answer] # [MATL](http://esolangs.org/wiki/MATL), ~~11~~ 10 bytes ``` Y@t!d0>AY) ``` Extremely inefficient examination of all permutations of the input. [Try it Online!](http://matl.tryitonline.net/#code=WUB0IWQwPkFZKQ&input=Wzk5LC0yLDUzLDRd) Explanation ``` % Implicitly grab input array Y@ % Compute all permutations (each permutation as a row) t % Duplicate this matrix !d % Transpose and take the differences between the values 0>A % Find the rows where all differences are > 0 Y) % Return only the row where this is true % Implicitly display the result ``` [Answer] # Python, 120 Bytes ``` def f(a):import time,threading;[threading.Thread(None,lambda b=b,c=min(a):print(time.sleep(b-c)or b)).start()for b in a] ``` This probably won't be the shortest answer but I feel like this algorithm belongs here. call with a list of integers, they'll be printed in a sorted manner to stdout. I wouldn't try it with too large numbers though. [Answer] # Ruby, 40 bytes Selection sort. Anonymous function; takes the list as argument. ``` ->a{r=[];r<<a.delete(a.min)while[]!=a;r} ``` [Answer] # Awk, 66 bytes ``` {b=$0;a[b]}m<b{m=b}n>b{n=b}END{for(i=n;i<=m;i++)if(i in a)print i} ``` Arrays in awk are like dictionaries, not like C arrays. The indexes can be non-contiguous, and they grow (and are created) as needed. So, we create an array `a` for the input, with each line being a key. And we save the min and max values. Then we loop from min to max, and print all keys which exist in `a`. `b` is just to avoid repeated usage of `$0`. [Answer] # Python 3, ~~91~~ ~~62~~ 47 bytes ``` def f(z): while z:m=min(z);z.remove(m);yield m ``` Thanks to [wnnmaw](https://codegolf.stackexchange.com/users/30170/wnnmaw) and [Seeq](https://codegolf.stackexchange.com/users/20356/seeq) for golfing help. The argument `z` should be a list. This is a variant of selection sort. I'm not sure how `min` stacks up against `built-in sorting functions`, since I'm not sure how Python implements `min`. Hopefully, this solution is still okay. Any golfing suggestions in the comments or in [PPCG chat](http://chat.stackexchange.com/rooms/240/the-nineteenth-byte) are welcome. [Answer] # Pyth - ~~15~~ ~~13~~ ~~11~~ 10 bytes Two bytes saved thanks to @Jakube. Bogosort. ``` f!s>VTtT.p ``` [Try it online here](http://pyth.herokuapp.com/?code=f%21s%3EVTtT.p&input=4%2C1%2C3&debug=0). I don't need the `h` cuz we are guaranteed no duplicates. [Answer] # MIPS, 68 bytes I wrote a simple unoptimized bubble sort implementation a while ago. Byte count begins at `loop` and ends at `li $v0, 10`, assuming that the list address and list length are already in memory. ``` Address Code Basic Source 0x00400000 0x3c011001 lui $1,4097 5 main: la $s0, list # List address 0x00400004 0x34300000 ori $16,$1,0 0x00400008 0x2411000a addiu $17,$0,10 6 li $s1, 10 # List length 0x0040000c 0x24080000 addiu $8,$0,0 8 loop: li $t0, 0 # swapped 0x00400010 0x24090001 addiu $9,$0,1 9 li $t1, 1 # for loop "i" 0x00400014 0x1131000b beq $9,$17,11 11 for: beq $t1, $s1, fend # break if i==length 0x00400018 0x00095080 sll $10,$9,2 13 sll $t2, $t1, 2 # Temp index, multiply by 4 0x0040001c 0x01505020 add $10,$10,$16 14 add $t2, $t2, $s0 # Combined address 0x00400020 0x8d4b0000 lw $11,0($10) 15 lw $t3, 0($t2) # list[i] 0x00400024 0x8d4cfffc lw $12,-4($10) 16 lw $t4, -4($t2) # list[i-1] 0x00400028 0x21290001 addi $9,$9,1 18 addi $t1, $t1, 1 # i++ 0x0040002c 0x016c082a slt $1,$11,$12 20 ble $t4, $t3, for # if list[i-1] > list[i] 0x00400030 0x1020fff8 beq $1,$0,-8 0x00400034 0xad4bfffc sw $11,-4($10) 21 sw $t3, -4($t2) # swap and store 0x00400038 0xad4c0000 sw $12,0($10) 22 sw $t4, 0($t2) 0x0040003c 0x24080001 addiu $8,$0,1 23 li $t0, 1 # swapped=true 0x00400040 0x08100005 j 0x00400014 24 j for 0x00400044 0x20010001 addi $1,$0,1 26 fend: subi $s1, $s1, 1 # length-- 0x00400048 0x02218822 sub $17,$17,$1 0x0040004c 0x1500ffef bne $8,$0,-17 27 bnez $t0, loop # Repeat if swapped==true 0x00400050 0x2402000a addiu $2,$0,10 29 li $v0, 10 0x00400054 0x0000000c syscall 30 syscall ``` Now I wait to be blown out of the water with x86... [Answer] # Julia, ~~28~~ 27 bytes ``` x->colon(extrema(x)...)∩x ``` [Try it online!](http://julia.tryitonline.net/#code=ZiA9IHgtPmNvbG9uKGV4dHJlbWEoeCkuLi4p4oipeAoKcHJpbnQoZihbOTksLTIsNTMsNCw2Nyw1NSwyMyw0Myw4OCwtMjIsMzYsNDVdKSk&input=) [Answer] ## Java 8, ~~112~~ 92 bytes Here is another selection sort. The input is a `List t` of integers and the sorted output is printed to standard out. ``` t->{for(;0<t.size();System.out.println(t.remove(t.indexOf(java.util.Collections.min(t)))));} ``` Update * -20 [16-08-21] Used a lambda [Answer] # [MATL](https://github.com/lmendo/MATL), 11 bytes ``` `t4#X<2#)tn ``` [Try it online!](http://matl.tryitonline.net/#code=YHQ0I1g8MiMpdG4&input=Wy0zIC03IC02IC01IC02IDUgNiA0IDMgMCBd) This sorts by the following procedure, which is O(n2): 1. Take the minimum of the array. 2. Remove that value from the array, and store it for subsequent display. 3. Apply the same procedure with the rest of the array, until it becomes empty. 4. Display all numbers in the order in which they were obtained. MATL is stack-based. The array with remaining values is kept at the top of the stack. The removed values are below, in order. At the end of the program all those values are displayed. The array at the top would also be displayed, but since it's empty it's not shown. ``` ` % Do...while loop t % Duplicate. Implicitly take input in the first iteration 4#X< % Compute index of mininum of the array 2#) % Push the minimum, and then the array with remaining entries tn % Duplicate and push number of elements, to be used as loop condition % Implicitly end do...while loop % Implicitly display stack contents ``` [Answer] ## Seriously, 6 bytes ``` ,;l@╨m ``` [Try it online!](http://seriously.tryitonline.net/#code=LDtsQOKVqG0&input=OTksLTIsNTMsNA) This does the same thing as many other answers: generate all permutations, select minimum. I kinda forgot that this would work while I was working on the below solution. Explanation: ``` ,;l@╨m ,;l@ push len(input), input ╨m minimum permutation ``` --- ## Seriously, 25 bytes (non-competing) This would be competitive if it wasn't for a bug in the shuffle command that I just fixed. ``` ,1WX╚;;pX@dXZ`i@-0<`MπYWX ``` [Try it online!](http://seriously.tryitonline.net/#code=LDFXWOKVmjs7cFhAZFhaYGlALTA8YE3PgFlXWA&input=OTksLTIsNTMsNCw2Nyw1NSwyMyw0Myw4OCwtMjIsMzYsNDU) This implements the best sorting algorithm ever: [Bogosort](https://en.wikipedia.org/wiki/Bogosort)! Explanation: ``` ,1WX╚;;pX@dXZ`i@-0<`MπYWX , get input 1W WX do-while: X discard ╚ shuffle ;; dupe twice pX@dX remove first element of first dupe and last element of second dupe Z zip `i@-0<`MπY test if all differences are positive (if any are not, the list is not sorted), negate (1 if not sorted else 0) ``` [Answer] # MATL, ~~17~~ 16 bytes Saved one byte creating null array thanks to @LuisMendo ``` vTbtX<-QI$(f8M+q ``` Bucket sort. Don't try it with a range greater than 231-1. [Try it online!](http://matl.tryitonline.net/#code=dlRidFg8LVFJJChmOE0rcQ&input=Wzk5LC0yLDUzLDQsNjcsNTUsMjMsNDMsODgsLTIyLDM2LDQ1XQ) Explanation ``` v % push an empty array T % push 1 b % bubble the input array up to the top of the stack t % duplicate it X< % find the minimum - % subtract min from input array Q % and increment to adjust for 1-based indexing I$( % resulting array used as indices of empty array % (the [] way up at the top) that are assigned 1 (from T) f % find the nonzero indices 8M % magically retrieve the 4th previous function input :/ (aka, the min input array value) + % add it to the indices q % and decrement ``` --- TIL: * You can initialize an empty array in MATL using `[]` and grow it, just like in MATLAB * How to use `(` for assignment indexing * How to use the `M` automatic clipboard --- [Answer] # R, 68 Bytes Takes input `i` and outputs `o` which is the sorted list. ``` o<-i for(j in 1:length(i)){ x<-(i-min(i))==0 o[j]<-i[x] i<-i[!x] } o ``` Explanation: ``` o<-i # Defines output as o for(j in 1:length(i)){ # Initializes loop for length of input x<-(i-min(i))==0 # Generates logical vector by finding the value 0 # of input less the minimum of input. o[j]<-i[x] # Puts the smallest value at position j i<-i[!x] # Removes the smallest value from input } # Ends loop o # Returns sorted list ``` Avoiding the permutations means it can sort large lists relatively quickly. The "trick" is that subtracting the smallest value from the input leaves a single 0 that determine both the smallest value and the position of the smallest value. [Answer] ## Clojure, ~~73~~ 35 bytes [Bogosort](https://en.wikipedia.org/wiki/Bogosort) :) ``` #(if(apply < %)%(recur(shuffle %))) ``` Earlier version: ``` #(reduce(fn[r i](let[[a b](split-with(partial > i)r)](concat a[i]b)))[]%) ``` Reduces to a sorted list `r` by splitting it into "smaller than i" and "larger than i" parts. I guess this is the [insertion sort](https://en.wikipedia.org/wiki/Insertion_sort). [Answer] # [Python 3](https://docs.python.org/3/), 53 bytes ``` lambda l:[i for i in range(min(l),max(l)+1)if i in l] ``` [Try it online!](https://tio.run/##JclBCoMwEEbhvaf4lwkdwTSKIHgSdZHSpg4kowQX9vRR6@rB@9bfNi9is@/HHFx8vR1CNzD8ksBgQXLy/ajIooKm6PYzD6PZ3xqmvCaWTXk1NISaYAlPgpm0Lv6Ci1pCRSivmw8 "Python 3 – Try It Online") [Answer] # [R](https://www.r-project.org/), 47 bytes implements bogosort. ``` function(l){while(is.unsorted(l))l=sample(l);l} ``` [Try it online!](https://tio.run/##DchLCoAgEADQq8zSgSHoX4SHCVMSJg0/tIjObr7lC8XIYrJTyXonGN/ntKyFjU120Yekj5rIMu7XXZ9x468YoURPHbU00Ag0AcFMsBCsiOUH "R – Try It Online") [Answer] # Retina, 95 Modified bubble sort. I suspect there are much better ways to do this, even without the retina sort builtin. ``` -\d+ $n \d+ $11 +`(1+) (n+) $2 $1 +`\b(n+) (\1n+)\|(1+)(1+) \3\b $2$3 $1$3$4 1(1) $.1 n+ -$.& ``` Stage 1 - convert -ve integers to unary with `n` as the digit; drop the `-` signs. * Stage 2 - convert +ve and zero integers to unary with `1` as the digit; add `1` to each one, so that zero is represented by `1`. * Stage 3 - Move all -ves to the front. * Stage 4 - Sort: move all -ves with the largest magnitude (i.e. smallest numerical) ahead of higher -ves. Move smaller +ves ahead of larger +ves. * Stage 5 - Remove 1 from, and convert +ve unaries back to decimal. * Stage 6 - convert -ve unaries back to decimal, including sign. [Try it online.](http://retina.tryitonline.net/#code=LVxkKwokKm4KXGQrCiQqMTEKK2AoMSspIChuKykKJDIgJDEKK2BcYihuKykgKFwxbispfCgxKykoMSspIFwzXGIKJDIkMyAkMSQzJDQKMSgxKikKJC4xCm4rCi0kLiY&input=OTkgLTIgNTMgNCA2NyAwIDU1IDIzIDQzIDg4IC0yMiAzNiA0NQ) [Answer] # Ruby, 22 bytes A quick permutation sort. Runs in O(n!) space and time. ``` ->a{a.permutation.min} ``` [Answer] ## Ruby, ~~26~~ 24 bytes Selection sort, similar to Value Ink's answer, but using a different approach for greater golfiness. According to the specification: "Input/output can be done in any method you choose, as long as it is human readable". I think this fits the description, output is an array of arrays with a single element. ``` ->l{l.map{l-l-=[l.min]}} ``` example: ``` ->l{l.map{l-l-=[l.min]}}[[2,4,3,1]] => [[1], [2], [3], [4]] ``` ]
[Question] [ Write a program fragment so that, when repeated N times it prints the Nth Fibonacci number. For example, if your program is `print(x)` then: * `print(x)` should print `1` * `print(x)print(x)` should print `1` * `print(x)print(x)print(x)` should print `2` * `print(x)print(x)print(x)print(x)` should print `3` * `print(x)print(x)print(x)print(x)print(x)` should print `5` * etc. First 2 items are 1 then each consecutive item in the sequence is the sum of the previous two. You may include a non-repeated header and footer, but a smaller header and footer will always beat an answer with a larger sum of header+footer. For example, a 1000 byte answer with no header wins from a 20 byte answer with a 1 byte footer. However, a 0 byte header 20 byte body will win from both. With header length being equal, smallest number of bytes, in each language, wins. ### Tips Output in unary Use shell escape codes like `\r` to erase the previous print. Use your languages implicit output feature ### Example Submission > > # [Python](https://www.python.org), 0 header/footer, 97 body > > > > ``` > if"k"not in globals():k=["","x"];print("x",end="") > else:k.append(k[-1]+k[-2]);print(k[-3],end="") > > ``` > > Output in unary > > > [Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3EzPTlLKV8vJLFDLzFNJz8pMSc4o1NK2ybaOVlHSUKpRirQuKMvNKNIBMndS8FFslJU2u1JziVKtsvcSCAqCIRna0rmGsNpA0itWEKgZyjGNhyiEWQe2D2QsA) > > > Comments are entirely valid, but solutions that don't use comments are extra impressive. [Answer] # [R](https://www.r-project.org/), 12 bytes, no header/footer ``` +(F=+T)->T;F ``` [Try it once online!](https://tio.run/##K/r/X1vDzVY7RFPXLsTa7f9/AA "R ‚Äì Try It Online") [Try it twice](https://tio.run/##K/r/X1vDzVY7RFPXLsTaDZn9/z8A) [Try it three times](https://tio.run/##K/r/X1vDzVY7RFPXLsTaDRf7/38A) [Try it five times](https://tio.run/##K/r/X1vDzVY7RFPXLsTajVT2//8A) [Try it \$n\$ times](https://tio.run/##K/qfV5obX5RakJpYUqxgo6tg@j@1LDFHoyCxqDhVo8S2uKQIKKmhpK3hZqsdoqlrF2LtpqSDpEdTU/P/fwA) Right-hand assignment `->` is useful for suppressing output. Paging [Robin Ryder](https://codegolf.stackexchange.com/users/86301/robin-ryder) and his [various](https://codegolf.stackexchange.com/questions/191393/i-multiply-the-source-you-probably-multiply-the-output/191416#191416) [solutions](https://codegolf.stackexchange.com/questions/196864/i-shift-the-source-code-you-shift-the-input/196869#196869) involving `->`. ## Why this works `F` and `T` are automatically assigned as variables for the constants `FALSE` and `TRUE`, and happily are coerced to `0` and `1` in arithmetic expressions. The shortest R answer to the canonical [Fibonacci challenge](https://codegolf.stackexchange.com/questions/85/fibonacci-function-or-sequence/248102#248102) uses `F<-T+(T=F)` as the body of a loop, using the fact that assignment returns the assigned value (right-hand side for `<-` and `=`) invisibly, so the updates to the values happen in the right order (and are made visible by `show`). In that challenge, `F` holds the leading value \$F\_n\$ and `T` holds \$F\_{n-1}\$. A few adjustments are required here: 1. `F` now holds the trailing value \$F\_{n}\$, and `T` is updated on each loop as `F+(F=T)->T` to be \$F\_{n+1}\$, on every iteration. 2. We use `F=+T` so that the first copy prints out `1` instead of `TRUE`. 3. Leading `+` and the infrequently-used right-hand assignment `->` operator to satisfy the concatenation requirement. 4. Trailing `;F` to use implicit output to print out the required value. [Answer] # [Piet](https://www.dangermouse.net/esoteric/piet.html) + [ascii-piet](https://github.com/dloscutoff/ascii-piet), 19 bytes (12√ó4=48 codels) ``` _TLDJdAaAQIbcr_cc _ ``` [Try Piet online!](https://piet.bubbler.one/#eJxdzD0KgDAMBeC7vDkFI1pqr1IcRCsI_kF1Eu9uqoPVkCEfL8mBduk8rHNsiKuna3JZCp2C81TmH-lXOlXxWfy8Z8lKklsTUUbE6Fb1LtaE4FdYKKVAGIdJZs6kRD60sH0zBk8Y5nXfJMN5AR3WNAg) [Try Piet online! (x6)](https://piet.bubbler.one/#eJyrVkrOT0lVsoqONrTQMbSEoFidaANkjhkyx9AImWeBLmWG4Jkh80xQFKIYbwiUM9UB6rUAcUxBHJAUmDfqqFFHjQhHWSIUxuooFacWKFkp6erqKuko5WTmAtmGBkAA5KUWJytZpSXmFKfqKGXmFZSWAOWUagEOzNYu) ![](https://piet.bubbler.one/api.svg?12,4,18,19,19,19,0,19,19,19,6,19,19,19,12,19,19,19,8,19,19,19,12,16,19,19,16,16,19,19,4,19,19,19,10,19,19,19,14,15,2,18,15,15,19,18,19,19,19,19) ``` A1 nop B1-F1 1 1 ! roll `1 0 roll`; an overall no-op if there were some values on the stack, but leaves 1 0 if empty (therefore pushes 1 0 on the first iteration only) F1-K1 dup 3 1 roll + apply Fibonacci to the top two values [a b] -> [b a+b] ``` When the program is repeated, the grid is concatenated vertically, putting A1's white cell on L1 and so on. At K1, two things can happen: * If there are more repetitions below, the IP keeps going down, running more iterations of Fibonacci. * Otherwise, it heads east, prints the top value as integer (J2-J3) and halts (J4-K4). [Answer] # [Thunno 2](https://github.com/Thunno/Thunno2), 4 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md) (no header/footer) ``` ∆Å+1\| ``` [Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPSVDNiU4MSUyQjElN0MmZm9vdGVyPSZpbnB1dD0mZmxhZ3M9) [2x](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPSVDNiU4MSUyQjElN0MlQzYlODElMkIxJTdDJmZvb3Rlcj0maW5wdXQ9JmZsYWdzPQ==) [3x](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPSVDNiU4MSUyQjElN0MlQzYlODElMkIxJTdDJUM2JTgxJTJCMSU3QyZmb290ZXI9JmlucHV0PSZmbGFncz0=) #### Explanation ``` ∆Å+ # Without popping, add top two values 1\| # Replace a 0 with a 1 # Implicit output ``` [Answer] # [Python](https://www.python.org), 34 bytes ``` a='x';b='' print(end=a);a,b=b,a+b# ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwdJkW3V19aWlJWm6FjeVEm3VK9Stk4BCXAVFmXklGql5KbaJmtaJOkm2STqJ2knKUJUGQE3Rhla6hrFcaflFClkKmXkKRYl56akahjqGBppWqRWpyRpZWsma1hBzNCH6FiyA0AA) Outputs in unary. ### How? Streamlined version of OP's example code [Answer] # T-SQL ~~171~~ ~~160~~ 159 bytes (no header or footer) -1 byte thanks to @MickyT ``` /* WHERE 1=0--// --/Select 0 x,1 y into T;EXEC('create trigger X on T for delete as if @@rowcount>0select x from DELETED') UPDATE T SET x=y,y=x+y;DELETE T-- ``` [Try it online (use MS SQL)](https://sqliteonline.com/) The trick is using comments to have the initial select and trigger creation on only the first repeat, and the `WHERE` clause preventing the deletion of the fibbonacci record on all except the final repeat. Selecting from `DELETED` then outputs it. [Answer] # [Itr](https://github.com/bsoelch/OneChar.js/blob/main/ItrLang.md), ~~5~~ 4 bytes (no header or footer) `√¢+1w` [online interpreter](https://bsoelch.github.io/OneChar.js/?lang=Itr&src=4isxdw) [2x](https://bsoelch.github.io/OneChar.js/?lang=Itr&src=4isxd-IrMXc=) [3x](https://bsoelch.github.io/OneChar.js/?lang=Itr&src=4isxd-IrMXfiKzF3) [Nx](https://bsoelch.github.io/OneChar.js/?lang=Itr&src=RrviKzF3qw==&in=NQ==) (uses `F` operator to repeat sequence input number of times) ## Explanation ``` √¢+1w ; implicitly start with 0,0 on stack √¢ ; push top value below second value a,b -> b,a,b + ; add top two values -> b,a+b 1w ; maximum of 1 and top stack value ; implicit output ``` [Answer] # [Cascade](https://github.com/GuyJoKing/Cascade), 6 bytes ``` #\| \? ``` [Try it online!](https://tio.run/##S04sTk5MSf3/X7mGK8ae6/9/AA "Cascade ‚Äì Try It Online") (prints `0`) [Try it online!Try it online!Try it online!](https://tio.run/##S04sTk5MSf3/X7mGK8aeC5n8/x8A "Cascade ‚Äì Try It Online") (prints `00`) [Try it online!Try it online!Try it online!Try it online!Try it online!Try it online!](https://tio.run/##S04sTk5MSf3/X7mGK8aeCz/5/z8A "Cascade ‚Äì Try It Online") (prints `00000000`) Outputs in unary with zeros. Uses the fact that \$f\_n = 1 + \sum\_{i=0}^{n-2} f\_{i}\$. ``` #\| Start evaluating at the first `#`; prints 0 once (acting as 1+) \? `\` Move to the second column; skip evaluating f(n-1) #\| `\|` Pass through \? `?` Evaluate both columns; the left column evaluates f(n-2) (by induction) #\| and the right passes through, eventually evaluating all branches ... down to f(1) ``` --- # [Cascade](https://github.com/GuyJoKing/Cascade), 10 bytes ``` #1 \+/ \\|\| ``` [Try it online!](https://tio.run/##S04sTk5MSf3/X9mQK0Zbnyumpub/fwA "Cascade ‚Äì Try It Online") (outputs 1) [Try it online!Try it online!Try it online!](https://tio.run/##S04sTk5MSf3/X9mQK0ZbnyumpgYb6/9/AA "Cascade ‚Äì Try It Online") (outputs f3 = 2) [Try it online!Try it online!Try it online!Try it online!Try it online!Try it online!](https://tio.run/##S04sTk5MSf3/X9mQK0ZbnyumpoZ01v//AA "Cascade ‚Äì Try It Online") (outputs f6 = 8) After repeating, the code looks like this: ``` #1 \+/ \\|\|#1 \+/ \\|\|#1 \+/ \\|\|#1 \+/ \\|\| ``` The 3 columns on the left are relevant. Read the explanation from bottom to top: ``` # Print the value as number \ \| Ignore one iteration and fetch fn +/ Iterate n-1 times (when n is the number of repetition): \\|\| (a, b) = (a+b, a) 10 Initialize to a = 1 (column 2) and b = 0 (column 3) ``` # [Cascade](https://github.com/GuyJoKing/Cascade), 3 bytes footer, 3 bytes body body: ``` \? ``` footer: ``` # ``` [Try it online!](https://tio.run/##S04sTk5MSf3/P8aeS0GZ6/9/AA "Cascade ‚Äì Try It Online") (outputs `0`) [Try it oTry it oTry it online!](https://tio.run/##S04sTk5MSf3/P8aeC4IUlLn@/wcA "Cascade ‚Äì Try It Online") (outputs f3 = 2 = `00`) [Try it oTry it oTry it oTry it oTry it oTry it online!](https://tio.run/##S04sTk5MSf3/P8aeCw0pKHP9/w8A "Cascade ‚Äì Try It Online") (outputs f6 = 8 = `00000000`) Outputs in unary with zeros. `?` evaluates the center (of the next row), and then evaluates the left (of the next row) because the center always evaluates to 0. This certainly achieves better encoding of fibonacci loop, ~~but I couldn't figure out how to include "print 0" in the loop~~. [Answer] # [Piet](https://www.dangermouse.net/esoteric/piet.html) + [ascii-piet](https://github.com/dloscutoff/ascii-piet), 53 bytes (15√ó7=105 codels), no header/footer ``` ttlddtN ub?fnNssSkKCVrTtTLcfkdtlElt?l??T lL sdD S?? ``` Program as picture: ![](https://piet.bubbler.one/api.svg?15,7,0,0,6,12,12,0,7,19,5,14,18,13,7,7,3,3,3,19,19,19,19,9,9,19,19,19,19,19,15,19,19,19,19,19,19,1,19,19,19,19,19,19,2,0,19,19,19,19,19,0,0,19,19,19,19,19,6,19,19,19,19,19,19,15,13,9,12,0,6,17,6,0,18,6,18,18,0,19,19,19,6,6,19,19,19,3,12,12,19,19,19,19,3,19,19,19,19,19,18,18,19,19,19,19,19) Output in unary. [Try Piet online!](https://piet.bubbler.one/#eJxtj8EOgjAQRP9lz9NkV6TQ_grhYLAmJKgk6Mnw725bjIi0e2jfbqczL-ru50C-aRgMCznEYlQtGnEoIUdIDSlQJVYgbu18SpmDW5MMpdywBe_S-OMf5D1o91XL6NBl6zpSpUmOzm2yX4NzoFwW9vvWxUAp9lrR_cZcaJLa4BY0hZE8GWMINPRXPQvr0luYOvKX0zAFUH8bnw_t0fwG5WBSOQ) [Try Piet online! x2](https://piet.bubbler.one/#eJztkEEOwiAQRe8y608C1tLCVUgXpmLSpGoTdGW8uwOtaa1tl66En8DwYIb5D6qvR0_WOQkJDbWLkiigDKuC4zWH2kOVUBmfjyRDnCmaionB_HBMly-SAW6w-KsVJNeR3qqWx45M3zBfLCavZOxXp6bLd_bejF4aep7NRDOSfd-VzJJRAxtKfLj_9_1Hvi_CChR8R5aEEARqmzPvleTBkQ812dOhDR7UXLr7jRk9X2YrsRI) [Try Piet online! x3](https://piet.bubbler.one/#eJztkEEOgyAQRe8y608CtaJwFeOisTQxsa0J7arx7h3URmvRAzTCT2B4MMP8F1X3syNbFBISGuoQJJFBGVaJgtcU6giVQyV8PpEEYfbRXEwMlodTujRKRrjBwq9WkFxHeqtaGjoyQ8N8MZu9kqFf3Tedf7IPZgzS0MtsJpjR2_dbycSMGtlY4sv93ffd97_2PQpLkHctWRJCEKipr7xXkgdHzldkL6fGO1B9a58PZtS9AXzV_lc) [Try Piet online! x5](https://piet.bubbler.one/#eJztkFEOgjAMhu_S559kExmMqxAeDM6EBJUEfTLc3W7MgDg4gBk0Gd23tfR7UXM_GyqrSkBAQR5sCOSQmqNGxWsGeYQsIFPen0kK-7psGUw01ptzuSxIPNxh9q82kNhGaq9bZifS08B8MF_cEnZe5YYuPtUnGVMoqHU1bWU4fb-ddEiUZ77Fl_3oPXqP3qP36P1PvAdhDRpMTyUlSUKgrr3ytxT8cGaGhsrLqRsMqL31zwczGt82LJjw) [Try Piet online! x10](https://piet.bubbler.one/#eJztkFEOgjAMhu_S559kExmMqxAeDM6EBJUEfTLe3Q5mwAmcoNBkdN_W0u9Fzf3sqKwqBQUDffChkENbjhoVrxn0EbqATnl_Jin8O2bLYGIRb87lslUS4A7zf7WB1DYye90yP5GdBuaD-eKW8vOacejiW32SMYWBiatZL2PU99_JrokKLLT4sS_exbt4F-_iXbyLd_Eu3sW7eBfv4j3yvgpr0OB6KilJEgJ17ZW_teKHMzc0VF5O3eBA7a1_PpjR-wOLYBtn) This is so bad but my brain is completely fried rn, this will do for now. Definitely can be golfed though ~~(watch @Bubbler get some insane 30 byte answer lmao).~~ Bruh ain't no way, Bubbler just post some insane [19 bytes answer](https://codegolf.stackexchange.com/a/264538/96039). Just move on and go upvote Bubbler's answer lmao. [Answer] # [C (gcc)](https://gcc.gnu.org/), 84 bytes (no header/footer) ``` t #ifndef A ,b;main(a){ #define At #define A printf("%d",a);} #endif t=a;a=a+b;b=t;A ``` [Try it online!](https://tio.run/##Rcg7CoAwDADQPacoLUKL9QShQ4@S/iSDQSSbePbq5vZ4ddtrnVPB8ZDWh8kQCx7E4inc4L5i6SbrT3NeLDq8XZqNFPAB16XxAE2ElGgtWJJinvMF "C (gcc) ‚Äì Try It Online") This really shows the power of the preprocessor üí™ [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) (no header/footer) ``` ¬º¬æ√Öf ``` [Try it online](https://tio.run/##yy9OTMpM/f//0J5D@w63pv3/DwA) or [verify the first ten iterations](https://tio.run/##ASsA1P9vc2FiaWX/VEUi/8K8wr7DhWb/IsK2S07Dl0Q/IiDihpIgIj8uViwuwrX/). Explanation:* ``` ¬º # Increase counter variable `¬æ` by 1 (which is 0 by default) ¬æ # Push counter variable `¬æ` √Öf # Pop and push the 0-based ¬æ'th Fibonacci value # (after which the top of the stack is output implicitly as result) ``` [Answer] # [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 16 bytes ``` (()[[]]({})<>{}) ``` [Try it online!](https://tio.run/##SypKzMzTTctJzP7/X0NDMzo6NlajulbTxg5I/P8PAA "Brain-Flak ‚Äì Try It Online") ``` ( # Push... () # One [[]] # Minus the current stack height ({}) # Plus peek the value on top of the stack <> # Move to the other stack {} # Plus pop the value on top of the stack ) # ``` The `(()[[]]({})` trick is a convenient way to initialize the first stack to a '1' if it's empty, and leave it unmodified if it's non-empty. Also it's not everyday that a brain-flak solution has an odd number of `<>`s! [Answer] # [Ruby](https://www.ruby-lang.org/), ~~26~~ 21 bytes ``` [a=$.+$.=a\|\|1];p [a] ``` [Try it online!](https://tio.run/##KypNqvxfUJSfbqukpPQ/OtFWRU9bRc82sabGMNa6QEErOjH2P1BGr7ikKLOAy9BAryQzN7W4uqaihksl0VYRqNSAK7UsMUcBZIZWBVftfwA "Ruby ‚Äì Try It Online") Thanks Value Ink, Jo King and Sisyphus for the improvements. ### In short When it's repeated, it will just increase the number and print nothing: ``` [a=$.+$.=a\|\|1] # -> initializes a with 1 #N times: p [a][a=$.+$.=a\|\|1] # -> update a then print the non-existing a-th element of [a] p [a] # -> print all elements of [a] ``` I didn't know that the splat operator could be used like this. [Answer] # [Uiua](https://www.uiua.org/), ~~89~~ ~~36~~ ~~25~~ 19 bytes, no header/footer/`tag` ``` :try(+,e)(1 0;) e= ``` [Try it online!](https://www.uiua.org/pad?src=4oi24o2jKCssZSkoMSAwOykKZSDihpA=) [Try it online!Try it online!](https://www.uiua.org/pad?src=4oi24o2jKCssZSkoMSAwOykKZSDihpAK4oi24o2jKCssZSkoMSAwOykKZSDihpA=) [Try it online!Try it online!Try it online!](https://www.uiua.org/pad?src=4oi24o2jKCssZSkoMSAwOykKZSDihpAK4oi24o2jKCssZSkoMSAwOykKZSDihpAK4oi24o2jKCssZSkoMSAwOykKZSDihpA=) [Try it online!Try it online!Try it online!Try it online!Try it online!Try it online!](https://www.uiua.org/pad?src=4oi24o2jKCssZSkoMSAwOykKZSDihpAK4oi24o2jKCssZSkoMSAwOykKZSDihpAK4oi24o2jKCssZSkoMSAwOykKZSDihpAK4oi24o2jKCssZSkoMSAwOykKZSDihpAK4oi24o2jKCssZSkoMSAwOykKZSDihpAK4oi24o2jKCssZSkoMSAwOykKZSDihpA=) The programs look a bit different in the links thanks to the auto-formatter; if you paste the program in as given it turns into that then works. Note the trailing newline. Although `tag` is the only non-random way to make an expression stateful, this exploits the ability to repeatedly shadow built-in constant `e`, as well as to catch empty-stack errors with `‚ç£ try`. For the first copy, the stack is empty, so: ``` try( ) Try: e Push Euler's constant, , then push the nonexistent stack element under it. try ( ) That errors, so ; discard the error message 1 0 and push 0 and 1. : Swap to 1 and 0. e= Pop the 0 to redefine e as 0. The stack now contains only 1 ``` which prints `1` as the only value on the stack if no further copies are appended. For the second copy, the stack is non-empty, so: ``` try( ) Try: e Push e (now 0), , then push the value under it (1), + and add them. try ( ) That doesn't error, so nothing weird happens to it. : Swap, so the old result (1) is on top and the sum (also 1) is on the bottom. e= Pop the old result to re-redefine e as 1. The stack now contains only 1 ``` then ``` try( ) Try: e Push e (now 1), , then push the value under it (1), + and add them. try ( ) That doesn't error, so nothing weird happens to it. : Swap, so the old result (2) is on top and the sum (1) is on the bottom. e= Pop the old result to re-redefine e as 1. The stack now contains only 2 ``` and so on. [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), no headers, no footers, just 3 bytes ``` !‚àÜf ``` [Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCIh4oiGZiIsIiIsIiJd) [or a test suite of the first 1 to 9 repetitions](https://vyxal.pythonanywhere.com/?v=2#WyJEIiwiYCIsIiHiiIZmIiwiYFxcXG4tXG4xIDEwIHIqxJYiLCIiXQ==) Hello to everyone who ports this in another stack language or independently discovers it. :p ## Explained ``` !‚àÜf ! # Push the length of the stack ‚àÜf # Push the lengthth fibonacci number, starting from f(0) = 1 ``` [Answer] # [Nekomata](https://github.com/AlephAlpha/Nekomata), 4 bytes (no header/footer) ``` À£+1I ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHHBgqWlJWm6FktPL9Y29FxSnJRcDBWByQAA) * [Attempt This Online!√ó2](https://ato.pxeger.com/run?1=m70iLzU7PzexJHHBgqWlJWm6FqtOL9Y29AQTS4qTkouhwjBpAA) * [Attempt This Online!√ó3](https://ato.pxeger.com/run?1=m70iLzU7PzexJHHBgqWlJWm6FutPL9Y29EQQS4qTkouhcjA1AA) * [Attempt This Online!√ó4](https://ato.pxeger.com/run?1=m70iLzU7PzexJHHBgqWlJWm6FltOL9Y29EQjlhQnJRdDFcAUAgA) A port of [@The Thonnu's Thunno 2 answer](https://codegolf.stackexchange.com/a/264509/9288). ``` À£+1I À£+ Add without popping; fails if length of stack is less than 2 1I Replace failure with 1 ``` [Answer] # [JavaScript (Node.js)](https://nodejs.org), 38 bytes, 0 Header/Footer Creates a anonymous function ``` (a=>a?b=>b?f=c=>c?c(f)(a):a()+b():1:1) ``` [Attempt This Online!](https://ato.pxeger.com/run?1=jdE9CgIxFARgbPcg8h5iMP6uK0musknMihA3shstvIpNQD2UHsMTKAQ7i1dNMV81c723YevSrRf14xSbcfkcghZSKyOkUY2wQlploUHQWGnAkQGseMUx69fgXbPY7Q-Am6Kwoe2Dd8yHHcBFuLP20CMCfsu_Hevc0ekIU6SoGUnNSWpBUkuSWpFUSVJrkuITGuM0Rpuf__bP16eU8wM) Lambda Calculus go brr [Answer] # [Ruby](https://www.ruby-lang.org/), ~~29~~ 23 bytes Dug around for a bit until I found this magical function called `at_exit`/`END` that could be used to ensure the number is printed once at the end. `$.` is 0 by default, which saves some bytes. Someone else can port the Unary solution if they want to. -6 bytes from dingledooper. ``` a=1;END{p$.} $.=a+a=$.# ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsGCpaUlaboW2xNtDa1d_VyqC1T0arlU9GwTtRNtVfSUIbJQRTDFAA) [x3](https://ato.pxeger.com/run?1=m72kqDSpcsGCpaUlaboWN10TbQ2tXf1cqgtU9Gq5VPRsE7UTbVX0lEkThhgGNRNmNgA) [x5](https://ato.pxeger.com/run?1=m72kqDSpcsGCpaUlaboWN4sTbQ2tXf1cqgtU9Gq5VPRsE7UTbVX0lGkpDLEa6gKYSwA) [Answer] # [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 41 bytes, not unary solution ``` for i in(1,a:=0): i,a=i+a,i or+print(a)# ``` [Try it online!](https://tio.run/##K6gsycjPM7YoKPqfnJ@SqmCroKSk9D8tv0ghUyEzT8NQJ9HK1kDTikshUyfRNlM7USdTIb9Iu6AoM69EI1FT@T9QdbShla5hLBdXakVqsgbYEC0Fc83/AA "Python 3.8 (pre-release) ‚Äì Try It Online") [Answer] # [vim](https://github.com/DJMcMayhem/V), 10 bytes ``` 0py$"_cla ``` Note that the above ends with an ASCII "escape" character which, at least in my browser, is invisible. Basically, this is `0py$"_cla<ESC>`. This produces the letter "a" once when run once, once when run twice, twice when run 3 times, 3 times when run 4 times, 5 times when run 5 times, 8 times when run 6 times, and so on. [Try it online!](https://tio.run/##K/v/36CgUkUpPjknUfr/fwA "V (vim) ‚Äì Try It Online") Here is an explanation, along with equivalent Python code, where `L` and `R` denote the text to the left and the right of the cursor, and `Y` denotes the contents of the current register: * `0`: move the cursor to the beginning of the line (Python: `L, R = '', L + R`) * `p`: paste the contents of the default register, and put the cursor at the end of it (Python: `L, R = L + R[:1] + Y[:-1], Y[-1:] + R[1:]`) * `y$`: set the default register to all the text after the cursor (Python: `Y = R`) * `"_`: when running the following command, do not set the default register to the deleted text * `cla<ESC>`: delete the character after the cursor (if there is one) and insert an "a" (Python: `R = 'a' + R[1:]`) Near miss: the program `y$0pcla<ESC>` would be an 8-byte solution, except that it generates the sequence at the wrong offset: running it twice produces "aa," running it three times produces "aaa," running it four times produces "aaaaa," and so on. The program `0py$cla<ESC>` doesn't work because the command `cla<ESC>` sets the default register to the deleted text (unless it's preceded with `"_`). [Answer] # Swift 5.8, no header/footer, 43 bytes ``` var x=0,y=1;defer{print(x)} (x,y)=(y,x+y)// ``` Port of [Value Ink's Ruby answer](https://codegolf.stackexchange.com/a/264529/106545). [Try it on SwiftFiddle!](https://swiftfiddle.com/3oetst3zlrfppnm7xwia3io3om) ## Swift 5.6, no header/footer, 106 bytes This was the original answer. Even though the other one is shorter and also works in 5.6, I'm leaving this one here for the absurdity of it. ``` var x = -1,y=1//" print(String(repeating:"1",count:y),terminator:"") (x,y)=(y,x+y) #if swift(<4) (#endif " ``` This abuses a bug (patched in 5.7) where, if an inactive `#if swift` block contains unmatched parentheses, the `#endif` may be followed by an ill-formed string literal, including one with no close quote. I want to elaborate on why this is so strange: When a `#if` block is inactive due to `os()`, `arch()`, `canImport()`, a `-D` flag, or `#if false`, it's still parsed, but not compiled: [example](https://swiftfiddle.com/qbhhzc2bpzbpnbzhoiwkoc4m2e). However, if it's inactive due to `swift()`, it isn't parsed. It's tokenized so that the compiler knows where the correct `#endif` is, but it's not fully parsed: [example](https://swiftfiddle.com/azuhx4cbvzbxpdd3vgmd5l73iy). So, the fact that mismatched parentheses inside an inactive `#if swift()` do anything is bizarre, to say the least. When this code is appended to itself, the redeclaration of the variables becomes an unused string: ``` var x = -1,y=1//" print(String(repeating:"1",count:y),terminator:"") (x,y)=(y,x+y) #if swift(<4) (#endif "var x = -1,y=1//" print(String(repeating:"1",count:y),terminator:"") (x,y)=(y,x+y) #if swift(<4) (#endif " ``` The lack of space before the line comment throws off SwiftFiddle's syntax highlighting; SE's highlighting is correct. With that out of the way, * [Try it on SwiftFiddle!](https://swiftfiddle.com/ls2tw2fyj5hkrdctoac5ynhmiy) * [x2](https://swiftfiddle.com/n2jjq4serffbxawn6clbm6nq7m) * [x3](https://swiftfiddle.com/bq7kcle4brh2jkj2uuzdbdcide) * [x4](https://swiftfiddle.com/piuscsb7i5b2dn3yfl7ue7fob4) * [x10](https://swiftfiddle.com/djiyatejlff7nlui4o3hyvuc3i) [Answer] # [Backhand](https://github.com/GuyJoKing/Backhand), 9 bytes ``` ~+~:rO!:@ ``` [Try it online!](https://tio.run/##S0pMzs5IzEv5/79Ou86qyF/RyuH/fwA "Backhand ‚Äì Try It Online") [Try it online! (x6)](https://tio.run/##S0pMzs5IzEv5/79Ou86qyF/RyoEkxv//AA "Backhand ‚Äì Try It Online") Backhand's IP jumps by three cells by default, bouncing off at edges. This code makes use of this property to the max. Since the length of the base program is a multiple of 3, any amount of repetition will run as follows: ``` ~ : ! ~ : ! ... (forward) set up the initial stack + r : + r : ... (backward) compute Fibonacci ~ O @ (forward) print the number and halt set up the initial stack: ~ pop off one element; no op on first iteration : dup; pushes two zeros on first iteration ! not; change the top zero to one ~ pop off one : dup 0 ! not to make it 1 ... compute Fibonacci: [a b] : dup [a b b] r reverse stack [b b a] + add [b a+b] print and halt: ~ pop off b O print a as num @ halt ``` [Answer] # [Node.js](https://nodejs.org), 36 bytes, no header/footer Returns the result in the exit code. The highest possible value depends on the operating system. I think that's 8-bit/unsigned on Linux and at least 32-bit/signed on (recent versions of) Windows. ``` a=0;b=1 process.exitCode=a=b+(b=a)// ``` See the exit code in the debug section: [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/0dbAOsnWkKugKD85tbhYL7Uis8QZKGObaJukrZFkm6ipr///PwA "JavaScript (Node.js) ‚Äì Try It Online") x1 [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/0dbAOsnWkKugKD85tbhYL7Uis8QZKGObaJukrZFkm6iprz@qhnI1//8DAA "JavaScript (Node.js) ‚Äì Try It Online") x10 [Answer] # [Haskell](https://www.haskell.org), 30 bytes, 0 bytes header, 0 bytes footer ``` q=0:scanl(+)1q;f=(q!!)$0 +1-- ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m708I7E4OzUnZ8GCpaUlaboW-wptDayKkxPzcjS0NQ0LrdNsNQoVFTVVDLgUtA11dSGKbmrmJmbmKdgqpORzKSgUFGXmlSioKJQkZqcqGBoAWYVw0TSIBpjpAA) # [Haskell](https://www.haskell.org), 44 bytes, 0 bytes header, 0 bytes footer, no comments ``` f where q=(0,1);qf@(f,g)=(g,f+g)where(f,g)=q ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m708I7E4OzUnZ2W0km6Ec0CAUuzSdAVbhZilpSVpuhY3ddIUyjNSi1IVCm01DHQMNa0L0xw00nTSNW010nXStNM1wbIQkUKInnW5iZl5QCMKijLzShTSIYILFkBoAA) [Answer] # [Labyrinth](https://github.com/m-ender/labyrinth), 14 bytes ``` # -( : =+{!@ ``` [Try it online!](https://tio.run/##y0lMqizKzCvJ@P9fQZlLV4PListWu1rRgev/fwA "Labyrinth ‚Äì Try It Online") [Try it online! (6x)](https://tio.run/##y0lMqizKzCvJ@P9fQZlLV4PListWu1rRgYs6vP//AQ "Labyrinth ‚Äì Try It Online") The "repeat the source" requirement is extremely hard in Labyrinth (maybe easier than Hexagony, where it can be rightout impossible, but still), especially to golf it down, mainly due to the IP routing across source boundaries. I experimented with many layouts for two full days, only to find that the second simplest layout can be golfed by 1 byte (the simplest being the one below). ``` # # push stack height [0 \| ] -( (- decrement and subtract from below [1 \| ] (implicit zeros are used) : :=+ duplicate, swap the tops of two stacks, add [1 \| 1] =+{!@ (one step of fibonacci) # the top is not zero, so turn right at the junction -( #(- push stack height(1), decrement, subtract (becomes noop) [1 \| 1] : so repeat running fibonacci until it hits the bottom row =+{!@ # -( : =+{!@ {!@ print the previous fibonacci and exit ``` # [Labyrinth](https://github.com/m-ender/labyrinth), 15 bytes ``` :1 ; : = + _=!@ ``` [Try it online!](https://tio.run/##y0lMqizKzCvJ@P/fypDLmsuKy5ZLmyveVtHh/38A "Labyrinth ‚Äì Try It Online") [Try it online! (6x)](https://tio.run/##y0lMqizKzCvJ@P/fypDLmsuKy5ZLmyveVtGBitz//wE "Labyrinth ‚Äì Try It Online") The "simplest layout" that uses `_` "push 0" at the junction to skip to the next iteration. [Answer] # [Headass](https://esolangs.org/wiki/Headass), 56 bytes ``` U+O[+O[ORO[]]+E.U-):R-OU[UO]OUO[]]+E;U({])UU+O[]]E:?-(}. ``` Prints the word `debug` fib(n) times, where n is the number of copies, separated by newlines. This relies on the fact that DSO doesn't actually provide any debug info when the debug operation is called. it just prints the word 'debug'. Pretty funny stuff! Linking up to 6 copies because that's how many it took to convince myself: [Try It Online!](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS4iLCIiLCIiLCIiXQ==), [Try It Online!x2](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS5VK09bK09bT1JPW11dK0UuVS0pOlItT1VbVU9dT1VPW11dK0U7VSh7XSlVVStPW11dRTo/LSh9LiIsIiIsIiIsIiJd), [Try It Online!x3](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS5VK09bK09bT1JPW11dK0UuVS0pOlItT1VbVU9dT1VPW11dK0U7VSh7XSlVVStPW11dRTo/LSh9LlUrT1srT1tPUk9bXV0rRS5VLSk6Ui1PVVtVT11PVU9bXV0rRTtVKHtdKVVVK09bXV1FOj8tKH0uIiwiIiwiIiwiIl0=), [Try It Online!x4](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS5VK09bK09bT1JPW11dK0UuVS0pOlItT1VbVU9dT1VPW11dK0U7VSh7XSlVVStPW11dRTo/LSh9LlUrT1srT1tPUk9bXV0rRS5VLSk6Ui1PVVtVT11PVU9bXV0rRTtVKHtdKVVVK09bXV1FOj8tKH0uVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS4iLCIiLCIiLCIiXQ==), [Try It Online!x5](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS5VK09bK09bT1JPW11dK0UuVS0pOlItT1VbVU9dT1VPW11dK0U7VSh7XSlVVStPW11dRTo/LSh9LlUrT1srT1tPUk9bXV0rRS5VLSk6Ui1PVVtVT11PVU9bXV0rRTtVKHtdKVVVK09bXV1FOj8tKH0uVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS5VK09bK09bT1JPW11dK0UuVS0pOlItT1VbVU9dT1VPW11dK0U7VSh7XSlVVStPW11dRTo/LSh9LiIsIiIsIiIsIiJd), [Try It Online!x6](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS5VK09bK09bT1JPW11dK0UuVS0pOlItT1VbVU9dT1VPW11dK0U7VSh7XSlVVStPW11dRTo/LSh9LlUrT1srT1tPUk9bXV0rRS5VLSk6Ui1PVVtVT11PVU9bXV0rRTtVKHtdKVVVK09bXV1FOj8tKH0uVStPWytPW09ST1tdXStFLlUtKTpSLU9VW1VPXU9VT1tdXStFO1Uoe10pVVUrT1tdXUU6Py0ofS5VK09bK09bT1JPW11dK0UuVS0pOlItT1VbVU9dT1VPW11dK0U7VSh7XSlVVStPW11dRTo/LSh9LlUrT1srT1tPUk9bXV0rRS5VLSk6Ui1PVVtVT11PVU9bXV0rRTtVKHtdKVVVK09bXV1FOj8tKH0uIiwiIiwiIiwiIl0=) ## Explanation: Overall strategy: Each repeat of the code (we will call them "chunks") just aims to print enough 'debug's to reach the next fibonacci number. So the first chunk needs to print 1, since fib(1) = 1, but chunk two doesn't want to print anything, since chunk one already got us to fib(2) = 1, but then chunk three wants to print one more, since fib(3) = 2... etc etc etc. Luckily, there is a sequence which describes exactly this phenomenon: `1 0 1 1 2 3 5 8 13 21...` It is the fibonacci sequence. Each chunk increments a global variable (called `i` in the explanation below) and runs a short loop to get fib(i) but with fib starting with 1, 0. Then, it prints 'debug' that many times before moving on to the next chunk. ``` U+O[+O[ORO[]]+E. code block 0 (and 2, and 4...) U+O if i exists, i++, else let i = 1 [+O let a = 1 [O let b = 0 RO dont worry about it []]+E go to code block 2(i-1)+1 with these values . end code block U-):R-OU[UO]OUO[]]+E;U({])UU+O[]]E:?-(}. code block 1 (and 3, and 5...) U-) ; if i == 0 U({]) : } while(a != r0){ ? print('debug') -( a-- (effectively) } U dont worry about it U+O i++ []]E go to code block 2i with the new i value : }else{ R-O i-- U[ r2 = a UO a = b ]O b = b + r2 UO dont worry about it []]+E go to code block 2i+1 with these new values . end code block ``` all those parts where i say not to worry about it are just things that have to do with the specific ways im shuffling values around on the queue, and it would take up too much space to explain while not adding much clarity. Like and subscribe ## [Headass](https://esolangs.org/wiki/Headass), 27 bytes + 7 byte footer, outputs numerically ``` U+O[]]E.U)UP:R-OU^[U]ODONE. ``` ### Footer: ``` UODONOE ``` This one doesn't score as well, but overall it is much shorter and actually outputs numerically rather than with debug messages, so I thought it'd be worth including here. [Try It Online!](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuIiwiVU9ET05PRSIsIiIsIiJd), [Try It Online!x2](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuIiwiVU9ET05PRSIsIiIsIiJd), [Try It Online!x3](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuIiwiVU9ET05PRSIsIiIsIiJd), [Try It Online!x4](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuIiwiVU9ET05PRSIsIiIsIiJd), [Try It Online!x5](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuIiwiVU9ET05PRSIsIiIsIiJd), [Try It Online!x6](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuVStPW11dRS5VKVVQOlItT1VeW1VdT0RPTkUuIiwiVU9ET05PRSIsIiIsIiJd) ### Explanation: Overall strategy: iterate through all of the even code blocks to count how many copies there are, ending up at the footer, which then uses this count to initialize a loop on code block 1 which just gets fib(n) in a normal way. I want to believe it's possible to have something similar to this with no header/footer, but I don't have any ideas for that yet. ``` U+O[]]E. code block 0 (and 2, and 4...) U+O if i exists, i++, else let i = 1 []]E go to code block 2i . end code block UODONOE code block 2(number of copies + 1) UO save i on the queue DO a=0 NO b=1 E go to code block b (1) U)UP:R-OU^[U]ODONE. code block 1 U) : NE while(i){ R-O i-- U^ r1 = a [ r2 = a U]O a = b + r2 DO b = r1 NE } (go to code block 1) UP print a . end code block ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes ``` ·πõ$‚Äò√Ü·∏û ``` [Try it online!](https://tio.run/##y0rNyan8///hztkqjxpmHG57uGPef@tHDXMUdO0UHjXMtQ7jAnIgsnPAskDBLCAGKn64q/vRxnWGBofbHzWtifwPAA "Jelly ‚Äì Try It Online") A niladic link that as shown outputs 1 but when concatenated n times outputs the nth member of the Fibonacci sequence. ## Explanation (example for n = 2) ``` ·πõ$‚Äò√Ü·∏û·πõ$‚Äò√Ü·∏û ·πõ$ \| Within a monadic chain, right argument (will be zero) ‚Äò \| Increment by 1 $ \| Following as a monad: √Ü·∏û \| - Member of the Fibonacci sequence ·πõ \| - Right argument, restoring the original argument of this monadic chain ‚Äò \| Increment by 1 √Ü·∏û \| Member of the Fibonacci sequence ``` [Answer] # [Fortran (GFortran)](https://gcc.gnu.org/fortran/), ~~77~~ 58 bytes body, ~~42~~ 13 bytes header and footer ``` !mandatory header program x !repeatable code if(j<1)i=1;l=i;if(l>0)write(,'(A)')('x',k=1,l);i=j;j=j+l !mandatory footer end ``` Output is unary and printed vertically. The code depends on the compiler to initialize local variables to zero, e.g. with `-finit-local-zero` for [GFortran](https://gcc.gnu.org/fortran/). Try it online: [1x](https://tio.run/##JcdBCkIhEADQfadop5ZCrm2CjiI/R8YmjflCnw7fFLR7D4dMyT1U/EOfMqrkx35TQtvO0RHExEDpV76c3EtoFnvwxl6dcdZsxt8henaJoKUG7cg7Lf2mnwU511UDUqcZeCyZw7vI@AI "Fortran (GFortran) ‚Äì Try It Online"), [2x](https://tio.run/##nctBCkIhEIDhfadop1MKubYJOoq8VMYmjUno0eGbgm7Q7v8WfxkyJXVfyy/0LqNKum1XpWLbMQBhiIwUv@TTAZ5CM9udM/YMBqxZjbticAyRsMWGbc@b/0/N/aLvpXCqD/WFOk3PY0nsX1nGBw "Fortran (GFortran) ‚Äì Try It Online"), [4x](https://tio.run/##1ctBCkIhEIDhfadop1MKubYJOoq8VMYmjUno0eGbgk7R7v8WfxkyJXVfyy/0LqNKum1XpWLbMQBhiIwUv@TTAZ5CM9udM/YMBqxZjbticAyRsMWGbc@b/zo194u@l8KpPtQX6jQ9jyWxf2UZHw "Fortran (GFortran) ‚Äì Try It Online"), [8x](https://tio.run/##7csxDgIhEEDR3lPYAQqJ1DgmHoXsAhkcwcySuPHwzpp4CQu7/4uXOw@OzZX8DXlwLxzv@1Uw63r2BsEHAgyfpcvJPBlH0ger9NUoo9Wq7A28JRMQaqhQj7T7y1@Uktos7ylTLIu4jA2Hoz5Fcq/EfQM "Fortran (GFortran) ‚Äì Try It Online") [Answer] # [Pyth](https://github.com/isaacg1/pyth), 10 bytes (no header/footer) ``` eaYfgTs>2Y ``` [Try it online!](https://tio.run/##K6gsyfj/PzUxMi09pNjOKPL/fwA "Pyth ‚Äì Try It Online") [2x](https://tio.run/##K6gsyfj/PzUxMi09pNjOKBLB@v8fAA) [3x](https://tio.run/##K6gsyfj/PzUxMi09pNjOKBIb6/9/AA) [4x](https://tio.run/##K6gsyfj/PzUxMi09pNjOKBI/6/9/AA) [10x](https://tio.run/##K6gsyfj/PzUxMi09pNjOKJJ2rP//AQ) ``` # implicitly assign Y=[] f # find the lowest number starting at 1 for which lambda T is true >2Y # the last two elements of Y s # summed gT # is less than or equal to T aY # append to Y e # return the last element of Y ``` [Answer] # [Nim](https://nim-lang.org/), 60 bytes (no header/footer, outputs in decimal) ``` var a,b=0;b=1;addQuitProc do{.noconv.}:echo a (a,b)=(b,a+b)# ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m704LzN3wYKlpSVpuhY3bcoSixQSdZJsDayTbA2tE1NSAkszSwKK8pMVUvKr9fLyk_PzyvRqrVKTM_IVErk0gEo1bTWSdBK1kzSVIWZAjYIZCQA) ## Without using comments, 82 bytes Includes a trailing newline. ``` when not declared a: var a,b=0;b=1;addQuitProc do{.noconv.}:echo a (a,b)=(b,a+b) ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m704LzN3wYKlpSVpuhY3g8ozUvMU8vJLFFJSk3MSi1JTFBKtuBTKEosUEnWSbA2sk2wNrRNTUgJLM0sCivKTFVLyq_Xy8pPz88r0aq1SkzPyFRK5NIBKNW01knQStZM0uSAmQy2AWQQA) ## Unary output, 46 bytes Port of loopy wait's Python answer. ``` var a,b="x";b="" stdout.write a (a,b)=(b,a&b)# ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m704LzN3wYKlpSVpuhY39coSixQSdZJslSqUrIGkEldxSUp-aYleeVFmSapCIpcGUFLTViNJJ1EtSVMZoguqGWYIAA) [Answer] # [><>](https://esolangs.org/wiki/Fish), 13 bytes ``` \\n; 1: 0@ + ``` [Try it online!](https://tio.run/##S8sszvj/PyYmz5rL0IrLwIFLQfv/fwA "><> ‚Äì Try It Online") When repeated, it looks like this: ``` \\n; 1: 0@ +\\n; 1: 0@ +\\n; 1: 0@ + ``` The first column sets up the stack, the second runs the Fibonacci loop, and the horizontal path prints and exits. Extra copies of `1 0`s are ignored. ]
[Question] [ Your task is to write a program, function, or snippet that will output one value if run forward, and another if run backward. The program must run without errors. The output can be any two distinct values, of the same data type. For example, `1` and `3`, `true` and `false`, or `'t'` and `'f'`. In languages without a concept of data types, such as brainf\\\* or text, any distinct values are allowed. This is a code golf challenge, shortest answer per language wins. Note that snippets are allowed (so something like `1-2` is valid, but don't expect any upvotes). [Answer] # Python 3, no comments or string literals, 106 bytes ``` x=quit y=x.__class__ y.__add__=print y.__pos__=x x+x++x+x x=__sop__.y tnirp=__dda__.y __ssalc__.x=y tixe=x ``` I've never liked how comments and string literals let you "turn off" most of your language's syntax in challenges like this, so I wanted to see how far I could golf things without using either comments or string literals. This is what I came up with. Since I don't have any way to disable the syntactical significance of parentheses, I cannot use the function call operator. Any attempt to do so would result in the reversed code having a closing parenthesis before the first opening parenthesis, which is invalid outside a comment or string literal. I also can't use `def` or container literals (aside from unparenthesized tuples), and my access to language features is in general extremely restricted. One thing I can do is take advantage of Python's operator overloading to call functions implicitly. My ability to define any classes or functions is extremely limited, but fortunately, there are enough tools lying around in the built-in namespace for me to use. Most built-ins don't let me perform the attribute assignment I need to redefine their operator overloads, but (unless Python is run with one of the flags that disables `site` importing) the auto-imported `site` module adds `quit` and `exit` objects to the built-ins. These objects are instances of non-C classes, so I can reassign their operator overloads. Setting `__add__` to `print` lets me use addition to print things, and setting `__pos__` to `quit` or `exit` lets me use the unary `+` operator to abort the program before the rest of the code runs. Without setting `__pos__`, I would need a bunch of additional code to make sure the "backwards" part of the code can find all the variables and attributes it needs to not fail. With `__pos__`, I only need to make sure the "backwards" code is still syntactically valid. Forward, the code prints ``` Use quit() or Ctrl-D (i.e. EOF) to exit ``` Backward, the code prints ``` Use exit() or Ctrl-D (i.e. EOF) to exit ``` (The messages are slightly different on Windows. For platform-independent output at the expense of 3 extra bytes, you can replace the middle line with `x+1++x++2+x`, printing `1` when run forwards and `2` when run backwards.) --- I also tried to figure out a way to do this by defining my own class instead of messing with `quit.__class__`. I got as far as the following: ``` if.1j:adbmal=1j class ton:adbmal a=lambda:j1.fi j1=a a.__dict__=a.__globals__ ``` `class ton:adbmal` is one of the very few combinations of class name and class body such that the class statement is syntactically valid backward. `tressa`, `led`, `labolg`, `tropmi`, and `esiar` would also have been valid class names (with a different class body, such as `not fi`), but `ton` is the only one where the reversed name can be part of an expression, giving the most flexibility. `if.1j:adbmal=1j` assigns a value to `adbmal` to make the class body succeed, while still being syntactically valid backward. The stuff with `a` and `j1` lets me use `j1.ton` to refer to my `ton` class, which is still a valid expression backward. At this point, I got stuck. I couldn't figure out how to get my class out of `j1.ton` and into a more useful variable. I can't assign attributes on `j1.ton` and still have valid syntax backward, so I can't set operator overloads. I also wanted to set [`builtins.__build_class__`](https://stackoverflow.com/questions/1832997/what-does-pythons-builtin-build-class-do) to my class so I could abuse the `class` statement to construct instances without the function call operator, but trying to put `j1.ton` on the right side of an assignment produces invalid syntax backward. If I had been able to name my class something like `fi` or `tpecxe`, I could have used tricks like `b:j1.fi` to get the class into an annotation and then `a.__dict__=__annotations__` to get it into `a.b`, but I couldn't find any way to get the class statement and the annotation tricks to hook up. Anything that was compatible with the class statement was incompatible with the annotation tricks. (You might wonder why I didn't abuse `builtins.__build_class__` to call an existing function directly, like `print`. I couldn't figure out a way to do that and have the output be deterministic, and I wanted deterministic output.) [Answer] # JavaScript, 19 bytes Returns `true` because of the assignment at the end, since JS treats that as defining a global variable. The first part is an arrow function, which is ignored. When run backwards, `eurt` is set to `NaN` (not a number), and since `NaN` is not greater than `true` (or equal), it returns `false`. ``` eurt=>true;NaN=true ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/P7W0qMS2pKg01ZqroCgzr0TDL9EPzNf8/x8A "JavaScript (V8) – Try It Online") ``` eurt=NaN;eurt>=true ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/P7W0qMTWL9HPmqugKDOvRAPEt7MtKSpN1fz/HwA "JavaScript (V8) – Try It Online") # JavaScript, 3 bytes A snippet which outputs `1`, or `-1` in reverse. Very simple. ``` 2-1 ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/v6AoM69Ew0jXUPP/fwA "JavaScript (V8) – Try It Online") ``` 1-2 ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/v6AoM69Ew1DXSPP/fwA "JavaScript (V8) – Try It Online") # JavaScript, 7 bytes Abuses the not equal to operator and the not operator, will output `false`, or `true` in reverse. JavaScript uses `NaN` as not-a-number. ``` 5==!NaN ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/v6AoM69Ew9TWVtEv0U/z/38A "JavaScript (V8) – Try It Online") ``` NaN!==5 ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/v6AoM69Ewy/RT9HW1lTz/38A "JavaScript (V8) – Try It Online") # JavaScript, 18 bytes Another boring solution, with comments instead of subtraction. Returns `1`, or `2` in reverse. I included the `print` statements in these. ``` print(1)//)2(tnirp ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/v6AoM69Ew1BTX1/TSKMkL7Oo4P9/AA "JavaScript (V8) – Try It Online") ``` print(2)//)1(tnirp ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/v6AoM69Ew0hTX1/TUKMkL7Oo4P9/AA "JavaScript (V8) – Try It Online") # JavaScript, 7 bytes Similar to the previous answer, but with assignment instead of equal-to. Uses the `atob` variable, which is a builtin in browser Javascript (decodes base64). Since TIO doesn't include browser builtins, I defined it just to keep it from erroring. Works as expected in console. Return `true`, or `false` in reverse. ``` 2!=atob ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/P7EkP8k2rTQvuSQzP09Ds7rWmqugKDOvRMNI0RYkp/n/PwA "JavaScript (V8) – Try It Online") ``` bota=!2 ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/P7EkP8k2rTQvuSQzP09Ds7rWmqugKDOvRCMpvyTRVtFI8/9/AA "JavaScript (V8) – Try It Online") [Answer] # [J](http://jsoftware.com/), 3 bytes ``` 1"_ ``` [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/DZXi/2tyFaWWpRYVp9rqKcQrGXJxpSZn5CukKRjCGJaWEJa6OoSGKocpgHEtLf8DAA "J – Try It Online") ### one or infinity... * `1"_` is the constant 1, turned into a verb of rank `"` infinity `_`. Hence always returns 1. * `_"1` is the constant infinity `_`, turned into a verb of rank `1`. Hence always returns infinity. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes ``` +1 ``` [Try it online!](https://tio.run/##y0rNyan8/1/b8P9/AA "Jelly – Try It Online") Prints 1. # [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes ``` 1+ ``` [Try it online!](https://tio.run/##y0rNyan8/99Q@/9/AA "Jelly – Try It Online") Prints 2. The reason for this is that Jelly's dyad-nilad structure chains differently on either side. `+1` becomes a monad meaning "plus one", which is applied to the Left Argument, which defaults to zero. `1+` does not become a monadic chain here (if I remember correctly - correct me if my Jelly theory is off; I'm a bit rusty on the structural component), but rather is seen as `1` set as the Left Argument, and then `+` is applied as a dyad to `(left, left)` in the default case of no Right Argument, giving `1 + 1`. Great challenge; I almost feel like this is a cheese. I don't know if I should be happy with this solution or feel bad for having such a short and trivial solution >\_<. This uses Jelly's structure to be fancy. A more boring answer would just be `01` (prints 1) and `10` (prints 10), or any other two-digit number and its reverse (that isn't a palindrome). [Answer] # bash, 12 bytes (no comments or string literals) ``` echo 0$ ohce ``` Prints "0$ ohce" ``` echo $0 ohce ``` Prints "bash ohce" # bash, 11 bytes (no comments or string literals) ``` echo ftnirp ``` Prints "ftnirp" ``` printf ohce ``` Prints "ohce" [Answer] # brainf\\\* 2 bytes ``` +. ``` [Try it online!](https://tio.run/##SypKzMxLK03O/v9fW@//fwA "brainfuck – Try It Online") Outputs 1 forwards, 0 backwards. Really randomdude999's answer [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 10 bytes ``` Print@ohcE ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78/z@gKDOvxCE/I9n1/38A "Wolfram Language (Mathematica) – Try It Online") Prints `ohcE`. ``` Echo@tnirP ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78/981OSPfoSQvsyjg/38A "Wolfram Language (Mathematica) – Try It Online") Prints `>> tnirP`. [Answer] # [R](https://www.r-project.org), 2 bytes ``` .1 ``` Prints `0.1`. ``` 1. ``` Prints `1`. Both numeric (double). [tio](https://tio.run/##K/r/31CPS8/w/38A) Less trivial? and for an explicit true/false ``` 2>1 # TRUE 1>2 # FALSE ``` [tio](https://tio.run/##K/r/38jOkIvL0M6I6/9/AA) [Answer] # [POSIX sh](https://wiki.debian.org/Shell) (Dash, Bash, Zsh, ...), 3 bytes ``` : ! ``` [Try it online!](https://tio.run/##S0kszvj/30pB8T8XkOBKTc7IV1Cx51JUsIKz/wMA "Dash – Try It Online") The builtin `:` discards its arguments and exits `0` (true). Reversed, `!` negates the exit code of `:` and exits `1` (false). [Answer] # [7](https://esolangs.org/wiki/7), 2 characters, 1 byte in 7's encoding ``` 31 ``` [Try it online! (forwards)](https://tio.run/##M///39jw/38A "7 – Try It Online") [Try it online! (reversed)](https://tio.run/##M///39D4/38A "7 – Try It Online") This should be the first valid 1-byte solution (because the existing 1-byte solution in BCT requires a particular value on its input to work, and isn't counting it in the byte count – that could only be assumed in a full program, and BCT full programs can't do I/O and must wipe all their working memory to be able to halt, thus have no way to halt with a value). 7's encoding packs multiple characters into a single byte: here are `xxd` hexdumps for the forward and reverse programs: ``` 00000000: 67 g ``` ``` 00000000: 2f / ``` This conceptually outputs a string: `31` for the forwards program, and an empty string for the backwards program. The output encoding is set to be the same as the input encoding; so if you encode the program in 7's encoding, you'll get a single byte of output which encodes the string `31` (and if you use ASCII instead, you'll get two bytes that encode the string `31` in ASCII). ## Explanation On the first pass through the program, the `3` appends a "print and pop" command to the stack, and the `1` appends a "push empty stack element" command to the stack. So, we end up forming a program on top of the stack. At the end of the first pass through the program, 7 will run the resulting program, but without popping it from the stack. With the forward version of the program, the "print and pop" command will attempt to print the program consisting of a "print" command and a "pop" command. That isn't a valid literal, so the 7 interpreter will construct code that's capable of constructing that stack element and print that instead; in this case, the code it finds for for "push a stack element that generates a 'print and pop' command then a 'push empty stack element command'" is `731` (i.e. basically the program we wrote, although our program appends to an implicit empty stack element, whereas the reconstructed program makes a new one). The print routine interprets the `7` as a command to set the output encoding to the same encoding that was used for the source code, and then the `31` is interpreted as a literal and gets printed. The command in question pops two things in total (the thing it's printing and the element below), so the stack now contains no data and thus there are no more passes through the program; it just exits (even though we push an empty stack element after this point, those don't affect the end-of-program behaviour). With the reverse program, we're pushing the empty stack element before the print attempt, rather than the other way round, so it's now an empty string that gets printed, and the remnants of the program (which are below it) get popped without printing them. Everything is now the same as in the forward program, so the reverse program also exits naturally and without error. [Answer] # [Keg](https://github.com/JonoCode9374/Keg), 2 bytes ``` 10 ``` [Try it online!](https://tio.run/##y05N///f0OD/fwA "Keg – Try It Online") # [Keg](https://github.com/JonoCode9374/Keg), 2 bytes ``` 01 ``` [Try it online!](https://tio.run/##y05N///fwPD/fwA "Keg – Try It Online") When run forwards, it prints `10`. When run backwards, it prints `01`. I might try to create a non-trivial answer soon, as this seems like a really great challenge! [Answer] # [Perl 5](https://www.perl.org/), 11 bytes ``` say$-,$$yas ``` [Try it online!](https://tio.run/##K0gtyjH9/784sVJFV0dFpTKx@P//f/kFJZn5ecX/dX1N9QwMDQA "Perl 5 – Try It Online") Outputs `0` when run forward. Outputs the current process number followed by 0 when run backwards. [Answer] # [MathGolf](https://github.com/maxbergmark/mathgolf), 2 bytes This one does not have any nilads or dyads inside the program. Just monads. ``` ±( ``` [Try it online!](https://tio.run/##y00syUjPz0n7///QRo3//wE "MathGolf – Try It Online") ## Explanation ``` ± Find absolute value of the implicit 0 ( Decrement 0, resulting -1. ``` Reversed: ``` ( Decrement 0, resulting -1. ± Find absolute value of -1, which results in 1. ``` [Answer] # [Actually](https://github.com/Mego/Seriously), 2 bytes Decrement empty value & push 1. ``` D1 ``` Reversed program decrements 1, outputting 0. ``` 1D ``` [Try it online!](https://tio.run/##S0wuKU3Myan8/9/F8P9/AA "Actually – Try It Online") # [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes The exact same answer ported to a different language. ``` <1 ``` [Try it online!](https://tio.run/##yy9OTMpM/f/fxvD/fwA "05AB1E – Try It Online") [Answer] # [HolyC](https://en.wikipedia.org/wiki/TempleOS), 12 bytes Like the C version, except using the implicit print in HolyC ``` "0"; // ;"1" ``` Prints 0 ``` "1"; // ;"0" ``` Prints 1 Spaces required by the compiler :) [Answer] # [MarioLANG](https://github.com/tomsmeding/MarioLANG), 3 bytes ``` : + ``` [Try it online!](https://tio.run/##y00syszPScxL///fikv7/38A "MarioLANG – Try It Online") Prints 0 ``` + : ``` [Try it online!](https://tio.run/##y00syszPScxL//9fm8vq/38A "MarioLANG – Try It Online") Prints 1 --- # [MarioLANG](https://github.com/tomsmeding/MarioLANG), 10 bytes ``` == :+ == ``` [Try it online!](https://tio.run/##y00syszPScxL//9fwdaWy0qby9ZW4f9/AA "MarioLANG – Try It Online") Prints 0 ``` == +: == ``` [Try it online!](https://tio.run/##y00syszPScxL//9fwdaWS9uKy9ZW4f9/AA "MarioLANG – Try It Online") Prints 1 [Answer] # [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/index.html), ~~15~~ 13 bytes ``` tis,A NAMETAG ``` [Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?K8ks1nFU8HP0dQ1xdP//PykxBQA) Prints ASCII character 1 (SOH). ``` GATEMAN A,sit ``` [Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?c3cMcfV19FNw1CnOLPn/PykxBQA) Prints ASCII character 0 (NUL). The previous answer ends with an "Unexpected EOF" error forwards because the END command (any ten-letter word) is omitted, and a "Mismatched IF/EIF" error backwards because EOF is encountered before an IF/EIF loop can end. The following answer terminates properly. # [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/index.html), 51 bytes ``` the difference between I and certain ridiculous men ``` [Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?BcGBDYAwCATAVX4dx6DwjST6Jkjj@PWuTyJyThblxGB/pHDAFHBWWwqVkb6uZ724qb2HxQ8) Prints a newline. ``` nem suolucidir niatrec dna I neewteb ecnereffid eht ``` [Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?BcGBDYAwCATAVX4dx6DwjST6Jkjj@PVOvPGu51qekQWlddERMhwQ@TUH6GJxzgzw7L2HxQ8) Prints a newline and a "vertical tab" character. (I really wanted to be able to make the programs make sense both backwards and forwards, but I'm not sure that's possible in English, and I don't know any other languages to try that out with.) [Answer] # Haskell, 52 bytes ``` a=0-- --b tnirp=b#a niam=main 1#a=niam main=print a ``` ==> prints "1" ``` a tnirp=niam main=a#1 niam=main a#b=print b-- --0=a ``` ==> prints "0" Explanation: ``` a=0-- -- FWD: define constant "a" to be 0 / BWD: No-op -- --b tnirp=b#a -- FWD: No-op / BWD: define a function "#" in two arguments and prints the -- -- second -- niam=main -- FWD & BWD: define constant "niam" to be the same as "main" -- 1#a=niam -- FWD: define a function "#" in two arguments that produces "main" if the first -- -- argument is 1 / BWD: define constant "main" to be the result of the function -- -- "#" applied to the arguments "a" and 1 -- main=print a -- FWD: define constant "main" to be an IO action that prints the value of "a" / -- -- BWD: define a function "a" in one argument that always produces the value -- -- of "niam" -- ``` Of course, there is also the shorter item: # Haskell, 29 bytes ``` main=print 1-- --0 tnirp=niam ``` which is much less interesting. [Answer] # Dyalog APL Boring solution using comments ``` 0⍝1 => 0 1⍝0 => 1 ``` Even more boring numeric solution: ``` 10 => 10 01 => 1 ``` Basic arithmetics: ``` 2-1 => 1 1-2 => ¯1 ``` [Answer] # [Whispers v3](https://github.com/cairdcoinheringaahing/Whispers), 31 bytes ``` 1 tuptuO >> > 1 >> Output 1 0 > ``` [Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fUKGktKCk1F/Bzo7LTsGQy85Owb@0pKC0BMg2ULD7/x8A "Whispers v2 – Try It Online"), [!enilnO tI yrT](https://tio.run/##K8/ILC5ILSo2@v/fTsGAy1ChpLSgpNRfwc4OyLbjsrNT8C8tKSgtUTD8/x8A "Whispers v2 – Try It Online") Hooray for strict parsing rules! The first and last lines are ignored, because they don't fit the right syntax. They come into action when reversed. [Answer] # [Fig](https://github.com/Seggan/Fig) 0.1.0, \$2\log\_{256}(96)\approx\$ 1.646 bytes ``` ," ``` [See the README to see how to run this](https://github.com/Seggan/Fig/blob/master/README.md) Argh. Beaten by Halfwit by more than half a byte. In the forward position, it prints a single newline. Backwards, `",`, it prints a comma followed by a newline. [Answer] # [Make](https://www.gnu.org/software/make/), ~~14~~ 15 bytes ``` x:# #$@$# #:y ``` [Try it online!](https://tio.run/##y03MTv3/v8JKmYtTWcVBRZmTS9mq8v9/AA "Make – Try It Online") Updated to add a trailing tab on the second line... Here's another one that's not as short, but seems interesting enough to post... Forwards it prints `x` and backwards it prints `y`. It works by referencing the `$@` symbol, which is defined as the target being made. The "command" run is just a comment to the shell, so it's a no-op. But by default Make echos the commands it runs. Also, the `$#` reference doesn't cause an error, and evaluates to an empty string, which allows `#$@$#` to work both directions without having to add more characters. [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 4 bits1, 0.5 [bytes](https://github.com/Vyxal/Vyncode/blob/main/README.md) ``` 2 ``` [Try it Online! (link is to bitstring)](https://vyxal.pythonanywhere.com/?v=1#WyIhIiwiIiwiMDEwMSIsIiIsIiJd) The bitstring form of this is `0101`, which translates to 2. Reversed - [Try it Online!](https://vyxal.pythonanywhere.com/?v=1#WyIhIiwiIiwiMTAxMCIsIiIsIiJd) (outputs 0) If we stretch the rules a bit, we can get two bits: [Try it Online!](https://vyxal.pythonanywhere.com/?v=1#WyIhIiwiIiwiMTAiLCIiLCIiXQ==) [!enilnO ti yrT](https://vyxal.pythonanywhere.com/?v=1#WyIhIiwiIiwiMDEiLCIiLCIiXQ==), which respectively output an empty string and 0 - 0 and 1 in unary. [Answer] # [Python 3](https://docs.python.org/3/), 17 bytes ``` print(1)#)2(tnirp ``` [Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69Ew1BTWdNIoyQvs6jg/38A "Python 3 – Try It Online") I promise this is the last trivial/cheese one I post; I'm trying to think of a more interesting solution. If I remember I'll see where I can get with this. [Answer] # [Pyth](https://github.com/isaacg1/pyth), 2 bytes ``` \" ``` [Try it online!](https://tio.run/##K6gsyfj/P0bp/38A "Pyth – Try It Online") Returns the string ' " ' (one set of double quotes) # [Pyth](https://github.com/isaacg1/pyth), 2 bytes ``` "\ ``` [Try it online!](https://tio.run/##K6gsyfj/Xynm/38A "Pyth – Try It Online") Returns "\" Oops, my earlier answer missed that they had to be the same data type. This answer returns two different strings, and relies on the fact that '\' makes a one character string of the input and that Pyth closes strings implicitly [Answer] # [Japt](https://github.com/ETHproductions/japt), 2 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) ``` 1g ``` Returns `1`. Reverse returns `-1`. `g` is the sign function when it has no arguments, and returns the sign of the argument minus the caller if called with an argument. So `g1` would be the sign of zero minus one because the default input is 0 [Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=MWc) [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes Push 1 onto the stack & negates. (This results in -1) ``` 1( ``` Negate empty value & push 1. Output 1 implicitly. ``` (1 ``` [Try it online!](https://tio.run/##yy9OTMpM/f/fUOP/fwA "05AB1E – Try It Online") [Answer] ## Ruby, 6 bytes ``` p:stup ``` Output ``` :stup ``` Reversed output ``` p ``` [Answer] # Ceylon (Snippet), 20 The same trivial thing as in many other languages: ``` print(1);//;)2(tnirp ``` Outputs 1. ``` print(2);//;)1(tnirp ``` Outputs 2. Given that parentheses need to be in the right order and you need `print` for output, I don't think this can be improved. A full program or function needs even more braces/parentheses mirrored, so no chance of getting it better. # Ceylon (anonymous function), 17 If we don't need to output anything, but just return it from an anonymous function, then this is enough: ``` ()=>// 1.2 //>=)( ``` A function which returns 1.2 (a floating point value). ``` ()=>// 2.1 //>=)( ``` A function which returns 2.1 (a floating point value). # Ceylon (expression with return value), 3 If we accept just an expression (which then can be printed), then we don't even need any comments: ``` 2.1 ``` Gives 2.1 (a floating point value). ``` 1.2 ``` Gives 1.2 (a floating point value). [Try all of them online](https://try.ceylon-lang.org/?gist=03f2449ba0a874bd89d095ea1e4aeb94) [Answer] # [Wren](https://github.com/munificent/wren), 32 bytes Basically just a port of the Python answer. ``` System.write(1)//)0(etirw.metsyS ``` [Try it online!](https://tio.run/##Ky9Kzfv/P7iyuCQ1V6@8KLMkVcNQU19f00AjtSSzqFwvN7WkuDL4/38A) ]
[Question] [ The goal of this code-golf is to create a code that lets the user input an ASCII string (contains only [printable ASCII characters](https://en.wikipedia.org/wiki/ASCII#Printable_characters)), and your program outputs the lower-case variant of this string. Important: you are NOT allowed to use a built-in function that converts the string (or just one character) to lowercase (such as `ToLower()` in .NET, `strtolower()` in PHP , ...)! You're allowed to use all other built-in functions, however. Another important note: The input string doesn't contain only uppercase characters. The input string is a mix of uppercase characters, lowercase characters, numbers and other [ASCII printable](https://en.wikipedia.org/wiki/ASCII#Printable_characters) characters. Good luck! [Answer] # Python 2.7 - 30 (with terrible and unapologetic rule abuse) ``` raw_input().upper().swapcase() ``` As an anonymous edit pointed out, you can do it in ~~27~~ 26 in Python 3: ``` input().upper().swapcase() ``` I'm flagrantly abusing the rules here, but... > > Important: you are NOT allowed to use a built-in function that converts the string (or just one character) to lowercase (such as `ToLower()` in .NET, `strtolower()` in PHP > , ...)! You're allowed to use all other built-in functions, however. > > > This takes the strings and coverts it to upper case. Then in a very unrelated method call, it reverses the case of the string - so that any lower case letters become upper case letters... and swaps any upper case letters to lower case letters. [Answer] Perl - 11 10 characters. ``` y/A-Z/a-z/ ``` `y///` is same as `tr///`! In action: ``` % perl -pe 'y/A-Z/a-z/' <<< 'Hello @ WORLD !' hello @ world ! ``` [Answer] ### Shell - 10 Translation of @Gowtham's Perl solution using `/bin/tr`. ``` tr A-Z a-z ``` Sample run: ``` % tr A-Z a-z <<<'Hello WORLD! @' hello world! @ ``` [Answer] ## Befunge-98 - ~~26 22 21~~ 19 ``` ~:''-d2/1-!' +,#@ ``` Relies on the fact that `(c-39)/26` is `1` only for character codes of uppercase ASCII characters (assuming integer division). For each character `c`, print out `c + (((c-39)/26)==1)' '`. Sample session: ``` % cfunge lower.b98 hello WORLD! hello world! This is a TEST!!11 az AZ @[`{ this is a test!!11 az az @[`{ ``` [Answer] ### Python 3, 48 ``` input().translate({c:c\|32for c in range(65,91)}) ``` [Answer] ## Ruby, 18 characters Nothing really interesting. ``` gets.tr'A-Z','a-z' ``` (run in IRB) Just for fun: a confusing version: ``` $,=$ ' ';$;=$,.tr'A-Z','a-z';$><<$; ``` Run like this: ``` c:\a\ruby>lowercase.rb Llamas are AMAZING! ``` Output ``` llamas are amazing! ``` [Answer] ## J - 30 ``` '@Z'(]+321=I.)&.(a.&i.)1!:1]1 ``` J is read right-to-left, so to break this down: 1. Prompt user for input: `1!:1]1` 2. Perform algorithm in code-point-space: `&.(a.&i.)` 3. Identify character range for each letter; the characters between codepoints "@" and "Z" are considered uppercase: `1=I.`. 4. For each uppercase codepoint, add 32: `]+32* ...` 5. Note that step (2) creates an implicit step (5): we started out by projecting from character to integer domain, so now that we're finished, we map those integers back onto characters. Obviously this particular implementation only considers ASCII; but the approach could be extended to at least the basic multilingual plane in Unicode. [Answer] C 64 63 59 55 chars ``` main(c){while(c=getchar(),~c)putchar(c-65u<27?c+32:c);} ``` [Answer] Golfscript - 17 Program: ``` {..64>\91<32+}% ``` Explanation: 1. `{}%` maps the code inside to every character in string. 2. `..` copies the top of the stack (the character) twice. 3. `64>` 1 if character code is greater than 64, else 0. 4. `\` swaps the two items on the stack (gets the second copy of the letter, and stores the result of `64>` in position two). 5. `91<` checks to see if character code is less than 91. Similar to step 3. 6. `` multiplies the results from steps 3 and 5 together. Only equal to 1, if both steps were true. 7. `32` multiplies the result of step 6 with 32. Will be 32 if step 6 was 1, else 0. 8. `+` add the result (either 32 or 0) onto the character code. Example output: ``` echo HelLO @ WorLD \| ruby golfscript.rb upper_to_lower.gs hello @ world ``` [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` u.š ``` Port of [@user8777 Python 3 answer](https://codegolf.stackexchange.com/a/12774/52210). [Try it online.](https://tio.run/##yy9OTMpM/f@/VO/owv//QzIyixU8ixUcFYIS81LycxVCUotLFJQNFQE) Explanation: ``` u # Convert the (implicit) input to uppercase .š # Switch the case (upper to lower and vice-versa) # (and output the result implicitly) ``` --- But without any case-altering builtins: # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~12~~ ~~11~~ 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` žn2ä`‡ ``` -1 byte thanks to @Emigna. -5 bytes thanks to @TheThonnu [Try it online.](https://tio.run/##yy9OTMpM/f//6L48o8NLEh41LPz/3yM1JydfRyE8vygnRREA) Explanation: ``` žn # Push builtin string "ABC...XYZabc...xyz" 2ä # Split it into two equal-sized parts: ["ABC...XYZ", "abc...xyz"] ` # Pop and push the strings separately to the stack ‡ # Transliterate all uppercase letters to lowercase ones # (after which the result is output implicitly) ``` [Answer] # Perl: 24 characters ``` s/[A-Z]/chr 32+ord$&/ge ``` Sample run: ``` bash-4.1$ perl -pe 's/[A-Z]/chr 32+ord$&/ge' <<< 'Hello @ WORLD !' hello @ world ! ``` [Answer] DELPHI ``` const UpChars:set of AnsiChar = ['A'..'Z']; var I: Integer; begin SetLength(Result, Length(pString)); for I := 1 to length(pstring) do Result[i] := AnsiChar((Integer(pString[i] in UpChars))(Ord(pString[i])+32)); WriteLn(Result); end; ``` [Answer] ### JavaScript - ~~109~~ 104 (ES6: 95) Thanks to some for the corrected version. ``` a=prompt();for(b=[i=0];c=a.charCodeAt(i);)b[i++]=String.fromCharCode(c\|(c>64&c<91)32);alert(b.join("")) ``` The following works if the browser supports ES6 function expressions: ``` alert(prompt().split("").map(c=>String.fromCharCode(c.charCodeAt()\|(c>"@"&c<"[")32)).join("")) ``` [Answer] ### Perl 18 ``` s/[A-Z]/$&\|" "/eg ``` Something like: ``` perl -pe 's/[A-Z]/$&\|" "/eg' <<<'are NOT allowed to: ToLower() in .NET, strtolower() in PHP' are not allowed to: tolower() in .net, strtolower() in php ``` and ``` perl -pe 's/[A-Z]/$&\|" "/eg' <<< "The input string Doesn't cOntaIn...( C0D3-@01F. ;-)" the input string doesn't contain...( c0d3-@01f. ;-) ``` For [@FireFly](https://codegolf.stackexchange.com/posts/comments/29281) : ``` perl -pe 's/[A-Z]/$&\|" "/eg' <<< "Doesn't this translate @ to \` and [\]^_ to {\|}~DEL? " doesn't ... @ to ` and [\]^_ to {\|}~del? ``` no. ### More generic: 18 chars anyway: ``` s/[A-Z]/$&\|" "/eg ``` ``` s/[A-Z]/$&^" "/eg ``` This wont change anything in state: ``` perl -pe 's/[A-Z]/$&^" "/eg' <<< "Doesn't ... @ to \` and [\]^_ to {\|}~DEL? " doesn't ... @ to ` and [\]^_ to {\|}~del? ``` All work fine, but the advantage of changing `\|` (or) by `^` (xor) is that the same syntax could be used for `toLower`, `toUpper` or `swapCase`: toUpper: ``` perl -pe 's/[a-z]/$&^" "/eg' <<< "Doesn't ... @ to \` and [\]^_ to {\|}~DEL? " DOESN'T ... @ TO ` AND [\]^_ TO {\|}~DEL? ``` and swapCase (18+1 = 19 chars): ``` perl -pe 's/[a-z]/$&^" "/egi' <<< "Doesn't ... @ to \` and [\]^_ to {\|}~DEL? " dOESN'T ... @ TO ` AND [\]^_ TO {\|}~del? ``` [Answer] ## javascript 80 ``` "X".replace(/[A-Z]/g,function($){return String.fromCharCode($.charCodeAt()+32)}) ``` (76 if you remove `"X"`) with `prompt` and `alert` - 92* ``` alert(prompt().replace(/[A-Z]/g,function($){return String.fromCharCode($.charCodeAt()+32)})) ``` [fiddle](http://jsfiddle.net/mendelthecoder/mhLXe/) thanks to @FireFly @some @C5H8NNaO4 and @minitech [Answer] # [K (ngn/k)](https://codeberg.org/ngn/k), ~~19~~ 17 bytes ``` {`c$x+32~"A["'x} ``` [Try it online!](https://ngn.codeberg.page/k#eJxLs6pOSFap0DY20qpTcoxWUq+o5eJKU1DySM3JyddRCM8vyklRVAIA1kgK9g==) Avoids using the `floor` builtin (`_:`). `~"A["'` generate a bit mask with 1's in the positions in the input containing uppercase letters * `32` multiply by 32, which calculates the offsets between uppercase and lowercase ASCII character codes `x+` add the offsets to the input (converting the string input to integers) * ``c$` convert back to characters [Answer] # x86-16 machine code, 15 bytes Assembled: ``` ac3c 417c 063c 5a7f 020c 20aa e2f2 c3 ``` Unassembled listing: ``` _LOOP: AC LODSB ; load byte from [SI] into AL, advance SI 3C 41 CMP AL, 'A' ; is char less than 'A'? 7C 06 JL _STORE ; if so, do not convert 3C 5A CMP AL, 'Z' ; is char greater than 'Z'? 7F 02 JG _STORE ; if so, do not convert 0C 20 OR AL, 'a'-'A' ; lowercase the char _STORE: AA STOSB ; store char to [DI], advance DI E2 F2 LOOP _LOOP ; continue loop through string C3 RET ; return to caller ``` Callable near function. Input string in `DS:[SI]`, length in `CX`. Output string in `ES:[DI]`. Output from PC DOS test program: [![enter image description here](https://i.stack.imgur.com/XZRQ3.png)](https://i.stack.imgur.com/XZRQ3.png) [Answer] ## R ### 71 characters: ``` chartr(paste(LETTERS,collapse=""),paste(letters,collapse=""),scan(,"")) ``` ### 83 characters: ``` a=as.integer(charToRaw(scan(,""))) b=a%in%(65:90) a[b]=a[b]+32 rawToChar(as.raw(a)) ``` [Answer] # Q, 18 ..... ``` {x^ssr/[x]..Q`a`A} ``` [Answer] # Q (16) ....... ``` {x^(.Q.A!.Q.a)x} ``` [Answer] # Python (33) If in doubt, use the shell. ``` import os;os.system('tr A-Z a-z') ``` Regrettably, this is still longer than Lego's solution. [Answer] ## PHP (42) Run from the command line: ``` -R'echo@str_ireplace($a=range(a,z),$a,$argn);' ``` `-R` and the single quotes are not counted. [Answer] ## PowerShell: 69 65 64 I've tried a half-dozen ways to get Replace to work the way I want it to without using the long `[regex]::Replace` syntax, but I haven't had any luck. If anyone else has an idea of what might work, please do suggest it. Golfed code: ``` [regex]::Replace((read-host),"[A-Z]",{[char](32+[char]"$args")}) ``` > > Changes from original: > > > * Rearranged last argument so that `[int]` is no longer needed, per suggestion in comments. > > > Explanation: `(read-host)` gets the user input. `[regex]::Replace(`...`)` tells PowerShell to use RegEx matching to perform replacement operations on a string. `"[A-Z]"` matches all uppercase letters. `{`...`}` tells PowerShell to use a script to determine the replacement value. `[char]"$args"` takes the current match and types it as an ASCII character. `32+` converts the character to an integer, representing the ASCII code, and increases the value by 32 - which would match ASCII code of the corresponding lowercase letter. `[char](`...`)` takes the resulting value and converts it back to an ASCII character. Demo of original: ![enter image description here](https://i.stack.imgur.com/QTd2k.jpg) (Current version tested - screenshot not yet posted.) [Answer] # k2, 15 bytes I am super late to this one, but I found this cool anyway. ``` {_ci 32+_ic x}' ``` Also: # Pyth, 10 bytes Doesn't really count because Pyth was created after this was posted. Still cool. ``` jkmC+32Cdw ``` [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~53~~ ~~49~~ 43 bytes -4 bytes thanks @AdmBorkBork -6 bytes thanks @Veskah ``` -join($args\|%{[char](32($_-in65..90)+$_)}) ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkmZb/V83Kz8zT0MlsSi9uEa1Ojo5I7EoVsPYSEtDJV43M8/MVE/P0kBTWyVes1bzfy2XSoWCrYKSh6uPj79CeH5RToqigmeJQmaxgqeOQgDI5GCQyQrupZWKSlxqKmkKDhVcEE0Qe9Qd1fX01KPUtdUTQYwqdU2oqv8A "PowerShell – Try It Online") [Answer] ## Vim, 6 bytes `gUUg~~` Or, if allowed, ## Vim, 3 bytes `guu` [Answer] Just for fun, because Java's my language. # Java - ~~162~~ 175 Fixed for OP's updates. ``` class a{public static void main(String[]a){String b="";for(char c:new java.util.Scanner( System.in).nextLine().toCharArray())b+=c>64&&c<91?(char)(c+32):c;System.out.print(b);}} ``` With line breaks and tabs* ``` class a{ public static void main(String[]a){ String b=""; for(char c:new java.util.Scanner(System.in).nextLine().toCharArray())b+=c>64&&c<91?(char)(c+32):c; System.out.print(b); } } ``` [Answer] # Javascript, 105 ``` prompt().split("").map(function(a){c=a.charCodeAt(0);return String.fromCharCode(c\|(c-64?32:0))}).join("") ``` Actually ther was no output form specified, so run it in console Yea, JavaScript really is verbose with charcode <-> string [Answer] Ruby: 66 ``` def l(s)s.bytes.map{\|b\|(65..90).include?(b)?b+32:b}.pack('c*');end ``` [Answer] ## C# - 108 ``` class P{static void Main(string[]a){foreach(var c in a[0])System.Console.Write( (char)(c>64&&c<91?c+32:c));}} ``` About 70 for just the method body. Add 5 chars to include a LF/CR in the output: ``` class P{static void Main(string[]a){foreach(var c in a[0]+"\n")System.Console.Write( (char)(c>64&&c<91?c+32:c));}} ``` A LINQ version would be shorter: ``` class P{static void Main(string[]a){a[0].Any(c=>System.Console.Write( (char)(c>64&&c<91?32+c:c))is P);}} ``` (103) .. except that it requires `using System.Linq;` (total: 121). ]
[Question] [ For this challenge, submissions should be a program or function shaped like a right triangle, which produces a right triangle of the same size. What is a right triangle? For this challenge, a right triangle consists of 1 or more lines, each containing a number of characters (assume all non-newline characters are the same width) equal to that line number: ``` . .. ... .... ``` Trailing newlines are allowed. The challenge: Your code should form a right triangle, and output a right triangle with the same height made up of any non-newline characters. As this is code golf, shortest answer in bytes per language wins. [Answer] # [R](https://www.r-project.org/), 34 bytes ``` # d= cat d(9^ (1:7) ,sep=" ")##### ``` [Try it online!](https://tio.run/##K/r/X5krxZYrObGEK0XDMo5Lw9DKXJNLpzi1wFaJS0lTGQT@/wcA "R – Try It Online") Outputs \$9^1\$ to \$9^7\$: ``` 9 81 729 6561 59049 531441 4782969 ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), 53 bytes Fixed error pointed out by @S.S. Anne ``` \ m\ ain (n){ 9<pr\ intf(\ "%d\n", n=9)\|\|\ main(n);} ``` [Try it online!](https://tio.run/##S9ZNT07@/z@GKzeGKzEzj0sjT7Oay9KmoCiGKzOvJE0jhktJNSUmT0mHK0/L1lKzpgaoEqgOqMy69v9/AA "C (gcc) – Try It Online") [Answer] # [brainfuck](https://github.com/TryItOnline/brainfuck), 1 byte ``` . ``` Outputs a single null byte. [Try it online!](https://tio.run/##SypKzMxLK03O/v9f7/9/AA "brainfuck – Try It Online") [Answer] # JavaScript (ES7), ~~43~~ 34 bytes A triangle of 7 rows, filled with `0`'s. ``` f =( s=` `)=> s[7]? '':0+s +f(0+s) ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/jctWg6vYNoErQdPWjqs42jzWnktd3cpAu5hLO00DSGn@T87PK87PSdXLyU/XSNPQ1PwPAA "JavaScript (Node.js) – Try It Online") ### Commented ``` f // f is a recursive function =( // taking s=` // a string s initialized to `)=> // a linefeed s[7]? // if s has more than 7 characters, '':0+s // stop recursion; otherwise append a 0, followed by s, +f(0+s) // followed by the result of a recursive call with 0 + s ``` [Answer] # [Perl 5](https://www.perl.org/), ~~66~~ ~~54~~ ~~53~~ 19 bytes ``` # ## use #### Quine ``` I am submitting this as a joke because I did not even bother trying to write some optimized code. Instead, I am using a module from CPAN that causes the program to print itself. The `Quine.pm` module can be found on CPAN and was released in January 2001, long before this question was posted here. So I assume that it is acceptable, as it seems to be the tradition in other Code Golf questions. Edit 1: Saved 12 bytes by removing the semicolon after the `use` statement. Edit 2: Thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld) for pointing out that I did not need the final newline character, saving one byte. Edit 3: Thanks to [petStorm](https://codegolf.stackexchange.com/users/92069/petstorm) who made a great improvement by putting the `use` statement and the module name on separate lines, reducing the program to only 19 bytes. This exercise that started as a joke is now a very competitive entry. It would be difficult to do better in a non-obscure language (insert joke about Perl's readability here). [Answer] # [Bash](https://www.gnu.org/software/bash/), 26 bytes The `dc` command turns out to be quite useful in code-golfing. ``` \ d\ c \ -e{\ 5..1\ 0}p \ ``` [Try it online!](https://tio.run/##S0oszvj/P4YrJYYrWSGGSze1OobLVE/PMIbLoFarQCHm/38A "Bash – Try It Online") [Answer] # [Python 2](https://docs.python.org/2/), ~~53~~ 43 bytes I think we are allowed to output different characters. Because of this, I simply printed \$10^i\$ at every iteration. ``` # ## ### i=1; exec\ "prin\ t i;i\ =10;"8\ ``` [Try it online!](https://tio.run/##K6gsycjPM/r/X5lLGYSUuTJtDa25UitSk2O4lAqKMvNiuEoUMq0ztWK4bA0NrJW0LGL@/wcA "Python 2 – Try It Online") [Answer] # [Haskell](https://www.haskell.org/), ~~76~~ ~~64~~ 53 bytes ``` u = (9 ^) <$>[ 1..9] main= mapM_ print u ``` [Try it online!](https://tio.run/##y0gszk7Nyfn/v5RLwZZLQcOSSyFOU4FLwUbFLppLwVBPzzKWKzcxM89WASiYm1jgGw9iFBRl5pUolCr8/w8A "Haskell – Try It Online") This prints the first 9 powers of 9. [Answer] # [Ruby](https://www.ruby-lang.org/), 34 bytes ``` ( ## 1.. 7)## .map{ \|x\|p(# 9*x)}# ``` [Try it online!](https://tio.run/##KypNqvz/X4NLWZnLUE@Py1wTyNDLTSyo5qqpqCnQUOay1NKq0KxV/v8fAA "Ruby – Try It Online") [Answer] # [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~64~~ ~~53~~ 43 bytes ``` ; ;; int s=1, i;for (;i++< 9;Print (s=9)); ``` Simply prints the first several powers of 9. [Try it online!](https://tio.run/##Sy7WTS7O/P/fmsvamiszr4Sr2NZQhyvTOi2/iEvDOlNb24bL0jqgCCSjUaxla6mpaf3/PwA "C# (Visual C# Interactive Compiler) – Try It Online") [Answer] # [Befunge-98 (FBBI)](https://github.com/catseye/FBBI), 34 bytes Outputs \$ 9^k, 1 \leq k \leq 7 \$. ``` v 8v <v1 v< @ > 9v .^ >\: a,:\|>1- ``` [Try it online!](https://tio.run/##S0pNK81LT9W1tPj/v4zLoozLpsyQq8xGwYHLTsFSq4xLL07BLsaKK1HHqsbOUPf/fwA "Befunge-98 (FBBI) – Try It Online") The first three lines ``` v 8v <v1 ``` push 8 (loop counter) and 1 (\$ 9^0 \$). The main loop can be written in a single line as ``` 9\1-a,:!#@_\:. 9* multiply by 9 \ swap to loop counter 1- subtract 1 a, output newline :! duplicate and invert loop counter #@_ quit if non-zero, continue east otherwise \ swap to 9^k :. duplicate and output 9^k ``` [Try it online!](https://tio.run/##S0pNK81LT9W1tPj/38KwjKvMxobLzlIrxlA3UcdKUdkhPsZK7/9/AA "Befunge-98 (FBBI) – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 1 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` 0 ``` [Try it online.](https://tio.run/##yy9OTMpM/f/f4P9/AA) Not much to say I guess.. --- If this was [code-bowling](/questions/tagged/code-bowling "show questions tagged 'code-bowling'") instead, we could do something like this (can be made as arbitrary large as you'd want it to, as long as the last three bytes are `₄»`): ``` 1 11 111 1111 11111 111111 1111111 11111111 111111111 1111111₄» ``` [Try it online.](https://tio.run/##yy9OTMpM/f/fkMsQhMAYQkBJGAWnEQw461FTi9ah3f//AwA) Explanation: ``` 1\n11\n111\n... # Push all these numbers one by one to the stack 111...111 # Push the number of the last line ₄* # Multiply it by 1000 to increase its size by 3 » # Join everything on the stack by newlines # (after which it is output implicitly as result) ``` [Answer] # [PHP](https://php.net/), 43 bytes ``` ; 1; for (;$i ++<8; )echo( 10*$i- 1)."\n"; ``` [Try it online!](https://tio.run/##K8go@G9jXwAkrbkMrbnS8ou4NKxVMrm0tW0srLk0U5Mz8jW4DA20tFQydbkMNfWUYvKUrP//BwA "PHP – Try It Online") Not that bad for PHP.. displays a triangle of "9" [Answer] # Java 10, 76 bytes (11 rows) ``` v -> {// var r=""; long i =0,s=1; for(;++i <12;r+=(s =9)+"\n") ;return r;} ``` Inspired by all the other answers. [Try it online.](https://tio.run/##LY7NCsIwEITv@xRLT4m19ecmMb6BXgQv6iHGVqIxLZs0INJnryn2sjA7zMz3VFEVz/tr0FZ5j3tl3BcQjQsV1UpXeBgl4jGQcQ/U7NSYO0Yu0reHdHxQwWg8oEM5RCh28F0sAKMiIJllAmyTcgbkcu7lSkDdEBN5bmC7WgvKJfMwkxueZxeXcRBUhY4ckugHMda33c2m@mkljuPvxMj@POcrKj4Bfnyo3mXThbJNVmCu1Mx11vKJtR9@) [Answer] # [C (gcc)](https://gcc.gnu.org/), 53 bytes ``` ; m\ ain (n){ 9/pr\ intf(\ "%d\n", n)&&mai\ n(n10);} ``` Prints powers of 10. [Try it online!](https://tio.run/##S9ZNT07@/9@aKzeGKzEzj0sjT7Oay1K/oCiGKzOvJE0jhktJNSUmT0mHK09TTS03MTOGK08jT8vQQNO69v9/AA "C (gcc) – Try It Online") [Answer] # [SQL (Oracle)](https://docs.oracle.com/database/121/SQLRF/toc.htm) 88 76 Bytes ``` ; / ABC DEFG HIJ/ SELECT LPAD(1, LEVEL,1) FROM DUAL CONNECT BY LEVEL < 12; ``` [Try it out](http://sqlfiddle.com/#!4/b181b/7/0) Output: ``` 1 11 111 1111 11111 111111 1111111 11111111 111111111 1111111111 11111111111 ``` Edit: Thanks [@Math Junkie](https://codegolf.stackexchange.com/users/65425/math-junkie), by following the rules I actually cut off 12 bytes. [Answer] # SmileBASIC 4, 3 bytes ``` \ ?0 ``` --- ``` 0 OK ``` [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 43 bytes ``` \ "\ "<\ >".\ "~Ta\ ble~#\ &/@Ran\ ge [81] ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78n277P4ZLCYhsYrjslPSAjLqQxBiupJzUOuUYLjV9h6DEvBiu9FSFaAstw9j/AUWZeSUK@g7p//8DAA "Wolfram Language (Mathematica) – Try It Online") [Answer] # [Canvas](https://github.com/dzaima/Canvas), 1 [byte](https://github.com/dzaima/Canvas/blob/master/files/chartable.md) Boring solution, just like everyone else. :) ``` \ ``` [Try it here!](https://dzaima.github.io/Canvas/?u=JTVD,v=8) # [Canvas](https://github.com/dzaima/Canvas), 4 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md) Non-trivial attempt. ``` ＼２＼ ``` [Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjNDJTBBJXVGRjEyJXVGRjND,v=8) # Explanation ``` ＼ # Draw a diagonal, with nothing on the stack # Errors silently # Newline: A character not in the code page. # It basically does nothing. ２ # 2: Push 2 onto the stack ＼ # Draw a diagonal with a length of 2 # Implicit output ``` [Answer] # [Bash](https://www.gnu.org/software/bash/) + GNU utilities, 43 bytes ``` \ s\ eq\ -f\ 'seq\ -s "\ " %f' \ $[+8]\|sh ``` [Try it online!](https://tio.run/##S0oszvj/P4arOIYrtTCGS0E3LYZLvRjCLFZQiuFSUlBNU1eI4VKJ1raIrQEpBgA "Bash – Try It Online") I couldn't quite get this down to 7 rows; I needed to pad it by 4 bytes to fill out the 8-row triangle (that's why I have `$[+8]` in the code instead of just `8`). --- BSD Challenge! If you take the same idea as the GNU solution above but use the BSD utility `jot` instead of `seq`, it's just one byte too long for a 7-row solution (which would be 34 bytes): ``` \ j\ ot\ -w\ 'jot\ -s "\ " ' 7\|sh # This is one byte too long for 7 rows :( . ``` If someone can see how to shave just 1 byte off this BSD version, that would get it down to a 7-row 34-byte solution. Here's a [TIO link to the BSD version](https://tio.run/##S0oszvj/P4YrK4YrvySGS0G3PIZLPQvCLFZQiuFSUlBXMK8BKQIA) if anybody wants to try their hand at eliminating that one last byte! This also works under OS X, if you have a Macintosh. (Obviously this version, like the GNU version in my main answer above, can be padded to be another 8-row 43-byte solution, but that's not as interesting.) [Answer] # [Clojure](https://clojure.org/), ~~103~~ ~~89~~ 76 bytes ``` ( ;; ;;; loop [i 9] (when( * i;;;; 99999999 )(println i)(recur(* i 9))));;;; ``` [Try it online!](https://tio.run/##LYtBCsAgDATv@wqP0R9InlJ6EqEpEiVU@vxUocPeZqe0fk@r7gTmNUbrfeCQkE/Qe1UlpCC8Tf5BpGGiT1NIJKtlGiWsIi720/0D "Clojure – Try It Online") Prints the first 11 powers of 9. Exits with an `ArithmeticException: integer overflow` when trying to multiply \$9^{12}\$ by \$99999999\$. [Answer] # [Bash](https://www.gnu.org/software/bash/), 64 bytes ``` \ d\ at\ e +\ d%n%\ m%n%j\ %n%Y%n\ %R%n%:z\ %n%7Y%n%\ T%n%N%n%F\ ``` [Try it online!](https://tio.run/##S0oszvj/P4YrJYYrsSSGK1VBG8hWzVON4coFklkxXEAyUjUPSAcBWVZVYAHzSLCKECDpB8RuMf//AwA "Bash – Try It Online") Not the shortest but kind of fancy. Displays current date in convinient format. Tried to do it locales intependent. Last byte for fancy too. [Answer] # [C (gcc)](https://gcc.gnu.org/), 53 bytes ``` \ m\ ain (n){ for(; 9/n;n= printf( "%0d\n" ,n,0));;} ``` [Try it online!](https://tio.run/##S9ZNT07@/z@GKzeGKzEzj0sjT7OaKy2/SMOay1I/zzrPlqugKDOvJE2DS0nVQCslJk@JSydPx0BT09q69v9/AA "C (gcc) – Try It Online") # [C (gcc)](https://gcc.gnu.org/), 53 bytes ``` \ m\ ain (n){ 9/n&& main(\ printf( "%0d\n" ,n,0));;} ``` [Try it online!](https://tio.run/##S9ZNT07@/z@GKzeGKzEzj0sjT7Oay1I/T02NKxfI14jhKijKzCtJ0@BSUjXQSonJU@LSydMx0NS0tq79/x8A "C (gcc) – Try It Online") [Answer] # C Preprocessor, 65 bytes (10 lines) ``` . .. ... .... ..... ...... ....... ........ ......... __TIME__// ``` Process with GCC/Clang with `-E` and `-P` options. (Thanks to Calculuswhiz for suggesting the `-P` option.) All the dots are ignored. The predefined `__TIME__` macro expands to a string of the form `"HH:MM:SS"`, meaning the last line stays the same length. [Answer] # [Husk](https://github.com/barbuz/Husk), 13 bytes ``` ₁ ¶₂ ΘI₃ ↑3İ⁰ ``` [Try it online!](https://tio.run/##ASIA3f9odXNr///igoEKwrbigoIKzphJ4oKDCuKGkTPEsOKBsP// "Husk – Try It Online") No comment characters, so every element does something... ``` ₁ # run function on line 1 (next line) ¶₂ # split output of function on line 2 (next line) ΘI₃ # prepend zero to identity of function on line 3 (next line) ↑3İ⁰ # first 3 elements of powers of 10 ``` --- # [Husk](https://github.com/barbuz/Husk), 1 byte Trivial (but included for completeness) ``` 1 ``` [Try it online!](https://tio.run/##yygtzv7/3/D/fwA "Husk – Try It Online") (there are many more like this... all equally uninteresting...) [Answer] # TeX, 188 bytes Nothing out of the ordinary, but for completeness: ``` % %% %%% %%%% %%%%% %%%%%% %%%%%%% %%%%%%%% \countdef ~=1%%%%%%% \countdef%% \i=26\loop%% \advance~1{%% \loop\advance% \i1.\ifnum\i<~% \repeat\endgraf} \ifnum~<18\repeat \bye%%%%%%%%%%%%%% ``` [Answer] # [PowerShell Core](https://github.com/PowerShell/PowerShell), 4 bytes Trivial power (up to 19 lines) ``` 1 10 ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNydFNzi9K/f/fkMvQ4P9/AA "PowerShell Core – Try It Online") --- # [PowerShell Core](https://github.com/PowerShell/PowerShell), 4 bytes p–n junction (90 variants) ``` 1 -1 ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNydFNzi9K/f/fkEvX8P9/AA "PowerShell Core – Try It Online") --- # [PowerShell Core](https://github.com/PowerShell/PowerShell), 26 bytes Twinkle, twinkle, little star ``` , '* ' 6\|%{ '' ++$ko} ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNydFNzi9K/f9fh0tdi0sLiM1qVKuBbHUFLS5tbZXs/Nr//wE "PowerShell Core – Try It Online") --- # [PowerShell Core](https://github.com/PowerShell/PowerShell), 26 bytes The magic number in nuclear physics and the quark soup of 3 quarks `$_` ``` , 1+ 2.. 6\|%{ "$_"* $_};$_ ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNydFNzi9K/f9fh8tQm8tIT4/LrEa1mktJJV5Ji0slvtZaJf7/fwA "PowerShell Core – Try It Online") [Answer] # [Pxem](https://esolangs.org/wiki/Pxem), Filename: 103 bytes + Content: 0 bytes = 103 bytes Filename as follows (if your filesystem doesn't support LF, I'm sorry) (also requires to be ASCII-compatible): ``` x .p x.n .o.n .o04x .-.t.z .c.zxxx .a.m.m.w .sx.oab.- .s.-.c.a.s .c.o.c.$.mx .s.s.+.tao.- .s.m.a.dxxxxx ``` Content is empty. [Try it online, with rpxem!](https://tio.run/##5VhLc9s2EL7zV8BxHEmxDCedTA@qFLsPt3WnaTpOcspkOBAJSohJggVAS3Li354uCJAAH3acTHOqPabJfXy7WAC7C4hyufu0j1K2PBbFlmbHUpHoEotlkPG4TCm6@BuoAUJRSqRErzQXzdGPQpAdUBGKaYJYzhQjKbum48dErOQUPVqmPLqcVBIIybKg4hYWy4qUhtGaRpfjx5KmieHQPA4a/KKU6/uoa4nP2mwhl7lcs0R9G/D5/Nvgvn23@DZxZrmkQn0b7IwUe/81ciHYFVG0sXF7YPU7piRao5ijj/D10TIQYgka7wEFMxmSE3SeK7qiYtLwERKESQpLflVmNFdnQnCBc7pBo5qEslIqtKS18qhR1o6238x//awG4W89BtqiEBSeegMK@k/JBEUjGZE8GQXDO/LcKVX4RCkRkiiiUnKBZhD2guUrxxKUxFTA16za6VM0UzQrgqG9bHUXH27qaJxaElpoWVKmKrSU8QRnVKwapc4K2EcvC5ojkseIbmlUKooI0uNACUvdBHIQGmvKFFXeLaqxzmZV2tExnyLt7SJnae2SKPPxr6CBl0TSnGS00p9MUUVsACdYD9zCGpSei2dtzyIeO8@0GY2jLQAKL0VEF6PR/f08ddqnRl2/GG9OtTDEtBapVmq43CmKFQ9Jba/lvYVdlklCBUBEpYAJnyJAWKk1gPVdejJ1XmAjF1iYzRroaGxRIMEbttsF0ZoIAG3031rRd43EPvrl7Kc3v6Hfzy7OGuKr17@cXVzgolQSPdj/YJVuZmj/g0a8mdoXHK3FzYNGrfbjcIGetjZq10H06BF69j1aLIyD8KWd047adfi277G2hWO@ySNYMe/8je57q1VuYZmY4/ec5eMH0wc@gplRbAqWkfPZhjIwOZ5MGMI6jsNwrD1oYQ8FhaaS9gzguqzpoExuSUb1/qGqFLl1vJ@2O9vcKn3wZv38@GXzNSpGaPEcjXipIFIhSdPR1DG5z/QZeUsrLzOfyQyT5R2l0KNbHc@rV81wKuHICEe82PkY0pDVWvBNSDakxbwyTEGvqJC0Da@TCyQIyL25kk4lqVVIHOp158NRw6NZKaBmteEuSDM1ICksChDbYn9yXjixjRHb@Ea2hrb1aTtDa43t2tCufRoxNNK2@RpyDRdE7KCGUuKklQ0dD3U28nEyw0kEz2qenyQ4yrlau7UEGrHRuOKsM@AXBFJUI3ZoHYxjKFE8920eGZYsl0qQqMvdM9wMFjIrUhaRrsBDI/BPyRWDGfVZBzWyKNJSNpyboT7E1hFczFxFa3ZCK9Ma8g@trqDW5l1tqwlvUZNgeAG9awpFvqZAoNXupAeW91yBrVIDCug4PMSeMpt5bYFzRKqY5ZDEICee/4VXVEVBP/sZoRMjjLmI0QwdPe3VXBx2bHj@tZJp1QSNRwfxaNIHiRyI3uID@vYdWibVV5dO3aWCDshAeK6cmk0SbR1L3OspJr6iTRVDY7aNQqcdqHH746AO16aZIdQo5TnFuqHxGpFWR4IrkYE4C89xl7J89HHVzaPHXtwm2mvWB9s4sLr@vS@hD6oa8taq1nX9iS7yHmgPbuvgtl2479C8UZbQ2mpAbyc9vxt555B3X4g8vxv52iFffyHy3dH4Q6MkXGwIbDzFYVcIQWXB81gfVzBpzGpz1nLES@C55sL2hBUZ5zy/poKfTD7fo5l@rN93@b2MlnurS5cuVbo0QSl6h1kepWVMT/rKh0/bbZuPVXvecqTqjLSVqqwtvg7xqIPoFen@wW4gIv5UEzfVpCMPZr7rzMHRPSfhfxjvVtyeDpyu64grL6ubLqWOuz1u3ZHaM6fb9DFDVaU6R@ronjYSPkzsYHRz0@MfeovCdjW31y696w/9Ta/tdrNEz8TRDLn7EdceDaVuz85RK3@TpbyfsT03nnazdfeoHn/xqB46Q3XTNjSiZOEBPx9L//MEJccSmhJ5nNzP5sHMC2TVDX6FyYPK5MFnTA5fEN16KzufI3031rgHB8oxL3TcpXd5Y8@c3oUR9gTvvFjLqFrzOMyYlPqux1xjDN7Y2eOk6QJshwpWsK0@oeInrYOt5rVOvIO4rSPpXVA9Hvr40V4wOtFOhINP@@j36lZshtZKFXJ2fLxial0uccSz482lujTxh7lYlgoxBJPAEkZjxBQiaAlPKLXg27JcrfTBpsaDqYtoLkGwzPXni/PXNSn49a8fX5wt5vMR@MAT7dzeKNgGuAi2OA8wrx5PngHlCCt8HeAIX2@38ElwBr@bAMst5mSJj@ANZCJgSC3F4e8hzraaLPEhVoQbmQwk4q3@CZzN4NXLNxc/ny1Go0/V@qj6wsq3KTKsyad/AQ) ## Output ``` x 10 120 xxxx xxxxx xxxxxx xxxxxxx xxxxxxxx xxxxxxxxx xxxxxxxxxx xxxxxxxxxxx xxxxxxxxxxxx xxxxxxxxxxxxx ``` ## With comments Note that every LF is replaced with '?'. ``` x?.pXX.z # print'x', LF .a?x.nXX.z # print LF.ord # two-digits .a?.oXX.z # print LF .a.n?.sXX.z .a04x?.-.tXX.z # i = 4 .a.zXX.z # loop .a?.c.zxxx?.aXX.z # essentially nop .a.m.m.wXX.z # j = i; while j!=0 .a?.sx.oXX.z # print'x' .aab.-?.s.-.cXX.z # j-- .a.a.s?.c.oXX.z # end-while; print LF .a.c.$.mx?.s.s.+.tXX.z # i++ .aao.-?.s.mXX.z # break if !(14>i) .a.a.dxxxxx # end-loop; end program ``` [Answer] # [Factor](https://factorcode.org/), ~~34~~ 26 bytes (~~7~~ 6 lines) -8 bytes / 1 line thanks to [Bubbler](https://codegolf.stackexchange.com/users/78410/bubbler)! ``` 10 6 iota n^v stack. ``` [Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQm1iSoVeWChIqVigoSi0pqSwoyswrUShOLSxNzUtOLVaw/q/AZWjApaBgxpWZX5IIZOTFlXEVlyQmZ@v9/w8A "Factor – Try It Online") Output: ``` 1 10 100 1000 10000 100000 ``` [Answer] # [Knight](https://github.com/knight-lang/knight-lang), 26 bytes ``` ; =a 0W> 6aO* '.'=a +1aQQQ ``` [Try It Online!](https://tio.run/##lVhbc9M4FH7vr3C9bGPFrpsyDDvEdTvQLTvMQgq0wOwmgciykhgcO/jSFhLvX2fPkW9yboWXTix9Ojd956J@pjc0ZpE3Tw6D0OU/mE/jWPk78CbT5CKKwkjhdwkP3FgRX4ssB7ymUcyb@9KZEvU2DRJvdj/uKok4nS1YGMRJlLIkjDRKFsnUi804TCPGbZrBjjf/MPUSHs8p41qxP6MJm2pHH7X@YDjoD2JYz7pDfflb/@MgGLa1QbB8QEj7iGRzzr/AbsSTNAoUSXi/M1wug9T3s1yYYzC7QxY@TxRqOya/40yT4MQqROAR27bpGf7oyhBb@m3GqQO2axTUmD4PJsmUGLTPhiRLQnDcCyYbrcoyEQ7l@p/XF1d2f2jloXpP/ZQv4oQmHlPmeAuaQxaOuRYeawxRvKER@NCx6IkQU@i3qK7n/jFbrPfp0CxlWd5YY6Swh2WSr1mUBiLsUXirBPw2Z0TmciedbFjf4p0QYtabgOulM4dHW3DlJuCehaHPabAFWO1mBateQjAi6lfEy0O3QrI4naN0Q4j65NKEAtdyRyUlG5wpvutzmzwpvpugNTfKBRnGv/poXoGgigdW04DxcJx7LblxcCAZD3zMf5VRQOFVCIqQrPGn5HqdTdfPh6T/9PDfYfvIOK4oTw8O8IJRpqZeq6iNZG46m1fOjEpnHoj8zMgo85Np7cp@bevBAW1c20TGKTJuvwnMcjLP03iq4Sqx8lS56L1/8fay9@qid20vsiJhXrg8SFY4cJ/7fXr4/dMQ/3YOn3yCEKwGQAgFY7NdbPIQBGxqxkcc9cYe4PIQ5TgMFJjrTQKUI3nSrzHDipq5wVtQmME3oecqnX28n9Jyq05QuS5ro3fBlyC8DRSvskxpNUxrjZoxFy6QMr5SdH@WXgNXXw8pBLRIF0pWSVVs1JyiritxpTxfc0anUukgGdTgnfDDJnyW@jvh7Sbc9W5kL@stvInGJZSiXtFkagJvAiZJPQK/t12Sek6DIEwUUAV3ojjflO88ClUwNXR/UXet8Hd6rz4Qn/qhpG8e3u7WV4tfLvc1etIhP@V8u/0T3vO7eRggSWnChUFKEkJtDPgE@HbDFTCOR2Ckv6WSnMj3trXenDZQDeLXtO9BQ9zNe6l6V8TvFSWV5JxHIY0SUlYQbLcrOaAiWCPqrs4g5BXO3xNKFs7ATC6OmGoVjF88JQcH18roQHO8NzhIIcemUs9RW0MCc1w8uBq2z8jg@Mh4KGiF0QBmOTKRQAMOK/kQQ818uEOw2sK2xJbLltrCH6R2qR5aseiBVTMvACa5ytc0BELxgIUpLnO3qzxY0Gy0qaUL@5t5ZBx3yHLZWalZxYCwq2ahE6MCUChcLz0IqnWZEZ9zCr1HrkD3ML4atXYyvkLJlwqLRXeFU9S9@hawLs3siH9NvYhr6jhWibHAEVlsOdIWm3q@@2kehYzHiHr@rnd@/eKyd1X35udQA3a1Zokl@QXDZF6J6TtSpxM3Lc2qlsSrs67IOn1pkqOcMRznaZyP8cOF@dg9YeVs7Jaz8dgWFpmlKahsf7yFTq886N3BRKHRJJ3hwPFg4erHmQJKlDF6CR3VwUZq8TywY5JJd4yB0JjhGHxlpIAltjJWoDib5r8DOuO2k/8G1bHN1mdXcUAzTbNCVZUlr@Iqak@8MNBUvZJahcdRypFTHKW6rRqKqjtmLqPq4rq6Vpsunc@cJaYXC/4aMC5l40KVEvGJFydcuEgWENpj7FXlA2nlLaGpPTBJmaUw5DmQqHeUJf43BXqBwqY0gi@YWfwwmEBNsmqC0KHtSBohMFXnkq@2SDJ4gWqOlAdErj31GJW/N6yNNFB7oXKDkqFQpr6LtgoV7j7USimrMODEqEKgvlYNjdinxZNMVQ3HfpaOxzwyqe@HTIMB3A0xSFTrACM6MJEbQHkHnpTEAcO/WEwHV28h47h2DF1Y7IiXnIm59cGDxFcHgUoIs5kZ@x68EDuGclhP9mWlYSSTLXubW9Zo3WM/BF8fPXzy6MnjPx4@edwWqxEN3HCGYZPPX6gGtU8xZLQR2hrSetpCSJXoeXgLqxy5u4EBZ6WZuSRzHIWzc2DAeejCoFm8nUi3NFe@TpMVuKcJzmyykc@EkVReOs@Xisel@Ctvj8R21Yeazm1xVH0jDhUF0eR33moVl7D7lQLx1mo@gBrIlxUSPZYNKZNJRv@J3DqtxrdGsEvL4sQN08S8jaBxg8A8z4lBGzG7bAqqtRbS1MFAPA/Lf38A1c62KCgQHaNMf8CS7kbwCLvk3ogY1fQk26QDWbGc1BeHLbfwshGGwzUkvhA2IdtrSOzQm5BHa0jxLtiA/H1dZrjZzo9rSDF/b0CeVMiKNOURnA2qI/KZ0@1nJtvOnG0/g8V/45mD6oxGywxv/MfmrDjWbeTg8t5jtOus56YlHct3jU0BsyVYo8rg43a5BJXSQ7@Z0tQsXuqOXel3GsI/VMIX2EetRvpaZCXxNpL5RS4C2r99SjcGi637/pd0SASttttwGs81AxuB9FnWsiodUchyqarNqF0VClyhojx0jyrXdtc1V@Ay63HAP6M6zJd1RXCIzvTaJN3Frly3jv9acu1rPuIBB9EZ/bD2bLrX@XC695hetvdaZgs@9WP65s2bHyN4hXrYsqwf/wM) ]
[Question] [ # The Program You are given two strings, A and B. A is the current position at which your timer is at, and B is the position at which your timer will stop. Both strings are in the format m:ss. You must write a program that determines the amount of time left which should also be formatted as m:ss or mm:ss. # Example ``` 0:00 0:01 -> 0:01 0:55 1:00 -> 0:05 1:45 3:15 -> 1:30 ``` [Answer] # Excel, 6 Bytes ``` =B1-A1 ``` Assuming A is in cell `A1` and B is in cell `B1` [Answer] # [MATL](https://github.com/lmendo/MATL), ~~17~~ 7 bytes ``` YOd15XO ``` Input is a cell array of strings, in the form `{'1:45' '3:15'}` or `{'1:45', '3:15'}`. [Try it online!](https://tio.run/nexus/matl#@x/pn2JoGuH//3@1uqGViam6grqxlaGpei0A "MATL – TIO Nexus") ### Explanation ``` YO % Input cell array of strings (implicit). Convert to serial date numbers d % Difference 15XO % Convert to format 15, i.e. 'HH:MM'. Display (implicit) ``` [Answer] ## [Bash](https://www.gnu.org/software/bash/) + coreutils, ~~44~~ 39 bytes ``` tr : \ \|dc -e?r60+r-r60-60~rn58PA~rnn ``` [Try it online!](https://tio.run/nexus/bash#@19SpGClEKNQk5KsoJtqX2RmoKVdpAuidM0M6oryTC0CHIFU3v//hlYmpgrGVoamAA) Explanation: using "1:45 3:15" as test case (last example). I show intermediary steps in quotes. ``` tr : \ \| # replace colons with spaces: "1 45 3 15" dc -e? # start dc script, push input to LIFO stack: "15 3 45 1" r60+ # turn time B to total seconds: "195 45 1" r-r60- # turn time A to total seconds and get difference: "90" 60~r # turn difference (time left) to minutes and seconds: "1 30" n58P # pop and print minutes, print colon (ASCII code 58): "30" A~rnn # print seconds. Padding with zeroes is done by dividing by #10 (A), and printing the quotient and the remainder. ``` Note that I don't check if the minute value needs zero padding, because the OP stated that the maximum value for `m` is 9. --- Below is my original 44 bytes answer, that used the `date` command to turn the total time left in seconds to the `m:ss` format. ``` date -d@`tr : \ \|dc -e?r60+r-r60-p` +%M:%S ``` [Answer] # Python 2, ~~90~~ ~~87~~ ~~83~~ 80 bytes Takes input like `"2:45","5:01"`. ``` a,b=[60int(s[-5:-3])+int(s[-2:])for s in input()] print'%d:%02d'%divmod(b-a,60) ``` [Try it online](https://tio.run/nexus/python2#@5@ok2QbbWaglZlXolEcrWtqpWscq6kN5RlZxWqm5RcpFCtk5gFRQWmJhmYsV0ERUFpdNcVK1cAoBUhnluXmp2gk6SbqmBlo/v@vZGRlYqqko2RqZWCoBAA) [Answer] # c, 86 ``` f(a,b,c,d){scanf("%d:%d%d:%d",&a,&b,&c,&d);d+=(c-a)60-b;printf("%d:%02d",d/60,d%60);} ``` Reads space-separated times from STDIN. [Try it online](https://tio.run/nexus/c-gcc#fYpBCsMgFET3nkIERdsf@m2rC6WHUT9CFg2hSVchZ7cSsu4shnkz06pOkKEAmW0paapaSAqSDhOgEqgMqoAiE@n60mVI5uJxyHH@jNN63vHev3TzCCQ9mri3vvF3Gidt2MZ4V9UmHmH@rosW4qR/9d4wIPJulmFwjtuOzIan449g3Q8). [Answer] ## Batch, 74 bytes ``` @set t=%2-(%1) @set/as=%t::=60+1%,m=s/60,t=s/10%%6 @echo %m%:%t%%s:~-1% ``` Replacing the `:` in the time with `60+1` converts it into an expression that calculates the number of seconds. Batch interprets leading zeros as octal so I prepend a `1` to the seconds to ensure decimal conversion; fortunately the two `1`s cancel out. [Answer] # C, ~~112~~ 100 bytes Thanks to @betseg for saving 11 bytes and thanks to @Johan du Toit for saving one byte! ``` i,j;f(chara,charb){i=atoi(b)-atoi(a);j=atoi(b+2)-atoi(a+2);j<0?i--,j+=60:0;printf("%d:%02d",i,j);} ``` [Try it online!](https://tio.run/nexus/c-gcc#XYzBCsIwEETvfkagkLUJJNV4yFr8ltRS3IC11Hgq/fa4qXrxNMN7w2RSEQd5vYV5H9QWHSzUhvQg2YHeMgDGL6mbH@OG8WwupLWKdXsy3uA005gGKareV6bpheJ3wDXfA40Slh0rnhmhSlgBOL3SUwouH@UcK1sWf8r6Y1EHb10ha34D) [Answer] # MySQL, ~~13~~ 22 bytes ``` select right(timediff(B,A),5) ``` expects the times in `A` and `B`. [Answer] # Bash + GNU utilities, 43 ``` date -d@`date -f- +%s\|dc -e??r-60/p` +%M:%S ``` [Try it online](https://tio.run/nexus/bash#PYyxCsMgFEX3fsVFIhmKVGntYIb0Bzp1zZAQn5BFgzrm3@0rgd7hcDjDDSmjUqnrUghbhNBOazCM@Lm1MBzYjXtY3J2xYoBPF/D2vMUa0MsyxR7d/@bA1PxSCcq/5lOCwlWWw69QNI5ZPfVtnzm9nfw0nyK1Lw). ### Explanation ``` date -f- +%s # read in 2 line-delimited dates and output as number of seconds since the epoch \|dc -e # pipe to dc expression: ?? # - read 2 input numbers r- # - reverse and subtract 60/ # - divide by 60 p # - output ` ` # evaluate date\|dc command date -d@ +%M:%S # format seconds difference and output ``` Note the `dc` expression divides by 60, because `date` reads the input as H:MM instead of M:SS. [Answer] # ECMAScript 6, 99 91 85 bytes ## Single Line: ``` f=s=>s.split`:`.reduce((a,e,i)=>a+e(!i?60:1),0);t=n=>~~(n/60)+":"+n%60;t(f(b)-f(a)); ``` ## Slightly formatted: ``` f=s=>s.split`:`.reduce((a,e,i)=>a+e(!i?60:1),0); t=n=>~~(n/60)+":"+n%60; t(f(b)-f(a)); ``` I feel there could be some some savings in there.. but I am not seeing them at present. Edit - excellent suggestions in the comments. [Answer] # PHP, ~~55~~ 53 bytes ``` <?=date('i:s',($s=strtotime)($argv[2])-$s($argv[1])); ``` takes input from command line arguments [Answer] # Rebol, 5 bytes ``` b - a ``` Assuming I didn't miss any rules.. Rebol has arithmetic built-in for a number of literal data types. This also applies to its descendants such as [Red](http://www.red-lang.org) [Answer] ## C#, 72 bytes ``` using System;a=>b=>((DateTime.Parse(b)-DateTime.Parse(a))+"").Remove(5); ``` Takes input as strings. `b="3:15"` `a="1:45"`. ### Explanation: Because `DateTime.Parse()` returns a Date in `hh:mm:ss` format, I am able to parse the result into a string using `+""`, then trim the trailing `:00`. This works with `hh:mm` because there are both 60 seconds in a minute and 60 minutes in an hour. `0:01` `0:00` returns `0:01` `1:00` `0:55` returns `0:05` `3:15` `1:45` returns `1:30` [Answer] # Pyth, ~~47~~ ~~45~~ ~~44~~ 40 Bytes ``` J.U-Zbm+60hdedmmvkcd\:.z%"%d:%02d".DJ60 ``` Takes the input separated by newlines. Pyth had no time built-ins useful for this. I tried some fancy eval() stuff but apparantly Pyth can't eval stuff with `` or any leading zeroes whatsoever. This got much longer than i hoped. Quite some bytes are spent on adding a leading zero to the output. At least I'm shorter than bash. Will add explanation if asked. [Try this!](https://pyth.herokuapp.com/?code=J.U-Zbm%2B%2a60hdedmmvkcd%5C%3A.z%25%22%25d%3A%2502d%22.DJ60&input=1%3A45%0A2%3A05&test_suite=1&test_suite_input=0%3A00%0A0%3A01%0A0%3A55%0A1%3A00%0A1%3A45%0A3%3A15&debug=0&input_size=2) ### alternative solution, 48 Bytes ``` J.U-Zbm+60hdh_dmmvkcd\:.z K%J60 s[/J60\:<KT\0K ``` [Answer] # Haskell, ~~98~~ ~~127~~ 86 Bytes ``` r(m:_:s)=60read[m]+read s a#b\|(d,m)<-divMod(r b-r a)60=show d++':':['0'\|m<=9]++show m ``` [Try it online!](https://tio.run/nexus/haskell#@1@kkWsVb1WsaWtmoFWUmpgSnRurDaIVirkSlZNqNFJ0cjVtdFMyy3zzUzSKFJJ0ixQSNc0MbIsz8ssVUrS11a3UraLVDdRrcm1sLWO1tcHiuf9zEzPzFGwVCkpLgkuKFFQUlAytTCyVlJWMrIzMlP4DAA "Haskell – TIO Nexus") But I wonder if there are some library functions for this EDIT: Removed import, also fixed an error where it showed m:s instead of m:ss Also, well-formatted version: ``` convert :: String -> Integer convert (a:_:b) = (read [a])60+(read b) diffTime :: String -> String -> String diffTime s1 s2 = let (d,m) = divMod (c b-c a) 60 in show d ++ ":" ++ pad2d m pad2d :: Int -> String pad2d n = ['0'\|n<=9]++show n ``` EDIT2: Golfed off (30?) bytes thanks to Laikoni! Also golfed some other misc. bytes. [Answer] # T-SQL, 238 bytes ``` CREATE PROCEDURE d @a time,@b time AS BEGIN DECLARE @d int DECLARE @s varchar(2) SET @d=datediff(s,@a,@b);SET @s=CAST(@d%3600/60 AS VARCHAR(3)) SELECT CAST(@d/3600 AS VARCHAR(3))+':'+(SELECT CASE WHEN LEN(@s)=1 THEN '0'+@s ELSE @s END)END ``` Usage: ``` EXEC d '00:55','01:00' ``` Seeing the PostGres example earlier I realised I hadn't seen many golfing attempts in SQL so I had a go at it in T-SQL. Now I know why you don't see much golfing in SQL :D [Answer] # [CJam](https://sourceforge.net/p/cjam), ~~34~~ ~~33~~ 25 bytes Saved 8 bytes thanks to Martin Ender! ``` {r':/60b}2\m60mds2Te[':\ ``` [Try it online!](https://tio.run/nexus/cjam#@19dpG6lb2aQVGukFZNrZpCbUmwUkhqtbhXz/7@hlYmpgrGVoSkA "CJam – TIO Nexus") Explanation* ``` { e# Start of block r e# Read one time from input ':/ e# Split on colons, gives [minutes seconds] 60b e# Convert from base 60 }2* e# Run this block 2 times e# At this point, we have the two times in seconds on the stack \ e# Swap top elements m e# Subtract 60md e# Divmod the result by 60, to convert back to minutes and seconds s e# Convert the seconds to a string 2Te[ e# Pad it to 2 characters by adding 0s to the left (T = 0) ': e# Push a colon character \ e# Swap top elements, bringing seconds back to the top ``` [Answer] ## T-SQL, 82 Bytes ``` select left(cast(dateadd(minute, datediff(S,'0:00','0:01')/60,114) as time(0)), 5) ``` [Answer] # Python, 160 bytes I am still new to code golf so if anyone has any suggestions, I would appreciate it. ``` a, b = input() def z(x): x = x.split(":") return int(x[0])60+int(x[1]) a, b = z(a),z(b) s, m = b-a,0 while s >= 60: s -= 60 m += 1 print(str(m)+":"+str(s)) ``` [Answer] ## REXX, 79 bytes ``` arg t q say right(time(,f(q)-f(t),s),5) f:return time(s,'00:'right(arg(1),5,0)) ``` [Answer] # Pyth, 28 ``` %"%d:%02d".Dh.+misMcd\:60Q60 ``` [Try it](https://pyth.herokuapp.com/?code=%25%22%25d%3A%2502d%22.Dh.%2BmisMcd%5C%3A60Q60&input=%5B%220%3A00%22%2C%20%220%3A01%22%5D%0A%5B%220%3A55%22%2C%20%221%3A00%22%5D%0A%5B%221%3A45%22%2C%20%223%3A15%22%5D&test_suite=1&test_suite_input=%5B%220%3A00%22%2C%20%220%3A01%22%5D%0A%5B%220%3A55%22%2C%20%221%3A00%22%5D%0A%5B%221%3A45%22%2C%20%223%3A15%22%5D&debug=0). ### Explanation ``` cd\: # lambda to split c on ":" sM # map to convert string to int mi 60Q # convert from base-60 list to give seconds .+ # delta of the two seconds values h # single-item list to int .D 60 # divmod by 60 %"%d:%02d" # format output ``` [Answer] # Java 7, 164 bytes ``` String c(String a,String b){long s=x(b,1)-x(a,1)+(x(b,0)-x(a,0))60,m=s%60;return(s/60)+":"+(m>9?m:"0"+m);}long x(String s,int i){return new Long(s.split(":")[i]);} ``` Explanation: ``` String c(String a, String b){ // Method with two String parameters and String return-type long s = x(b,1) - x(a,1) // Get difference in seconds from input times + (x(b,0) - x(a,0)60, // plus the difference in minutes times 60 to get the seconds m = s%60; // Temp variable of seconds after we've subtracted the minutes (used multiple times) return (s/60) // Return minutes +":" // plus ":" +(m>9?m:"0"+m); // plus seconds (with a leading 0 if necessary) } // End of method long x(String s,int i){ // Separate ethod with String and Integer parameters and long return-type return new Long(s.split(":")[i]; // Return either minutes or seconds of String parameter based on the index } // End of method ``` Test code:* [Try it here.](https://tio.run/nexus/java-openjdk#hY1Ba4QwEIXv@yuGQGGmujbSKlSx/QP1tMdlD9GVEkiimLi1iL/dRteedy5v3vC9N7US1kI5LSfXS/MNNe6LCPelokm1Xm0xYhXGdBxReAlwtfxuOdFzykNd2KeU533jht6gfUk5BSxjAeqP90@dMc4CTfm81Y3/j2wojQNJ0z0GpvmBL0@gjWynpEPfQGd58cEFoBsqJWuwTjgvt1ZeQQtp9rLzBQRNB/BTgoZiKyuR8u10@rWu0VE7uKjztFMGdVQj4xnnLIRVY0YP4SRZ4XgNPYLj7G2DX7M42eH5MC9/) ``` class M{ String c(String a,String b){long s=x(b,1)-x(a,1)+(x(b,0)-x(a,0))60,m=s%60;return(s/60)+":"+(m>9?m:"0"+m);}long x(String s,int i){return new Long(s.split(":")[i]);} public static void main(String[] a){ M m = new M(); System.out.println(m.c("0:00", "0:01")); System.out.println(m.c("0:55", "1:00")); System.out.println(m.c("1:45", "3:15")); } } ``` Output:* ``` 0:01 0:05 1:30 ``` [Answer] # TXR Lisp, 101 bytes ``` $ txr -e '(awk (:let (s "%M:%S")) ((mf (time-parse s)) (prn (time-string-local (- [f 1].(time-utc) [f 0].(time-utc)) s))))' 13:49 14:49 01:00 0:13 1:47 01:34 5:01 5:59 00:58 6:00 6:00 00:00 6:00 5:00 59:00 ``` Condensed: `(awk(:let(s"%M:%S"))((mf(time-parse s))(prn(time-string-local(-[f 1].(time-utc)[f 0].(time-utc))s))))` [Answer] # [Ruby](https://www.ruby-lang.org/), 91 bytes ``` require'time';t=Time;d=t.parse($[1])-t.parse($[0]);puts t.at(d.to_i).utc.strftime '%H:%M' ``` [Try it online!](https://tio.run/nexus/ruby#@1@UWliaWZSqXpKZm6puXWIbAqStU2xL9AoSi4pTNVS0og1jNXWRuAaxmtYFpSXFCiV6iSUaKXol@fGZmnqlJcl6xSVFaSBjFNRVPaxUfdX///9vaGVi@t/YytAUAA "Ruby – TIO Nexus") Takes input from command line arguments. ### Invocation: ``` ruby outatime.rb $A $B ``` ### Example: ``` ruby outatime.rb 1:45 3:15 ``` Output: > > 01:30 > > > [Answer] ## PowerShell 47 Bytes ``` param($s,[timespan]$f)($f-$s).ToString("h\:mm") ``` Simple timespan math and coverting to hour and seconds string. [Answer] # JavaScript, 88 bytes ``` a=>b=>{c=a.split`:`,d=b.split`:`;return +c[0]-d[0]-d[1]>c[1]?1:0+":"+(+c[1]+60-d[1])%60} ``` [Try it online!](https://tio.run/nexus/javascript-node#S7P9n2hrl2RrV51sm6hXXJCTWZJglaCTYpsE51gXpZaUFuUpaCdHG8TqpkAIw1i7ZCBhb2hloK1kpaStoQ3iapsZgOU0Vc0Mav8n5@cV5@ek6uXkp2ukaSgZWhkbKGlqKBlYGZsqaWr@BwA "JavaScript (Node.js) – TIO Nexus") ## Explanation: Splits the inputs on the colon ``` c=a.split`:`,d=b.split`:`; ``` Converts string to int ``` +c[0] ``` Gets the minute value ``` +c[0]-d[0]-d[1]>c[1]?1:0 ``` Gets the second value ``` (+c[1]+60-d[1])%60 ``` Returns the string minutes:seconds ``` return +c[0]-d[0]-d[1]>c[1]?1:0+":"+(+c[1]+60-d[1])%60 ``` ]
[Question] [ The Challenge In as few characters as possible, find the value of \$i^n\$, given \$n\$, a positive integer greater than 0. This should be outputted as a String. For those that don't know, \$i\$ is defined such that \$i^2=-1\$. So: * \$i^1=i\$ * \$i^2=-1\$ * \$i^3=-i\$ * \$i^4=1\$ This then repeats.. Rules * If your language supports complex numbers, don't use any functions or arithmetic that could work this out. * Floating point inaccuracies are fine for answers that would return decimals anyway, but integer inputs should give exact results Bonus Points -5 if you can work the value out where n is also negative -15 if you can work out the value for any real number (this bonus includes the -5 from the above bonus) Good luck! [Answer] # Ruby, score -2 (13 bytes, -15 bonus) ``` ->n{[1,90n]} ``` Features include: no rounding errors! (if you pass the input as a Rational) --- posted by the author, Kezz101* > > If you support any real number you can output in any valid complex form. > > > Negatives scores make my adrenaline rush forth. Thus the rules get abused are made use of to achieve this noble goal. Creates an anonymous function and outputs an array with 2 entries representing a complex number in polar form (angular unit: degrees). [Answer] # CJam, 12 characters - 5 = 7 ``` 1'iW"-i"]li= ``` [Test it here.](http://cjam.aditsu.net/) Supports negative inputs. ``` 1 "Push 1."; 'i "Push the character i."; W "Push -1."; "-i" "Push the string -i."; ] "Wrap all four in an array."; li "Read STDIN and convert to integer."; = "Access array. The index is automatically taken module the array length."; ``` The result is printed automatically at the end of the program. # Mathematica, ~~22~~ ~~20~~ 19 characters - 15 = 4 ``` Sin[t=œÄ#/2]i+Cos@t& ``` This is an anonymous function, which you can use like ``` Sin[t=œÄ#/2]i+Cos@t&[15] ``` (Or assign it to `f` say, and then do `f[15]`.) Supports reals and gives exact results for integer input. Note that the `i` is not Mathematica's complex i (which is `I`). It's just an undefined variable. Also, despite the order of the expression, Mathematica will reorder the output into `R+Ci` form. [Answer] ## Python 2 - (24-5)=19 ``` lambda n:'1i--'[n%4::-2] ``` Most credit belongs to @user2357112, I just golfed his answer from the comments on [this answer](https://codegolf.stackexchange.com/a/41726/31625) a bit more. Explanation: Starts at the index `n%4` in the string `'1i--'`. Then iterates backwards in steps of two over each letter in the string. So, for example, `n=6` would start at index 2, the first `-`, then skip the `i` and take the `1`, to return `-1`. @xnor pointed out a same-length solution: ``` lambda n:'--i1'[~n%4::2] ``` ## [Pyth](https://github.com/isaacg1/pyth/) - (14-5)=9 I can only seem to get 14, no matter how I try to reverse/slice/etc. :'( ``` %_2<"1i--"h%Q4 ``` Which is essentially the same as the above python answer, but in 2 steps, because pyth doesn't support the full indexing options of python. [Try it online.](https://pyth.herokuapp.com/) I'm going to go have a talk with isaacg about Pyth indexing ;) [Answer] ## TI-BASIC (NSpire) - 5 (20 characters-15) ``` cos(nœÄ/2)+sin(nœÄ/2)i ``` If you want to recieve a complex return value, replace the `i` at the end with `ÔÄØ`(complex i). [Answer] # [Marbelous](https://codegolf.stackexchange.com/a/40808/8478), 43 bytes Not really a winner, but Marbelous is fun. :) ``` }0 ^0 =0&2 &1 }0 ^1\/ =0&02D3169 \/\/&0&1&2 ``` This is a program which reads the input as a single integer from the first command-line argument. Note that the input is taken modulo 256, but this doesn't affect validity of the result for inputs greater than 255, because 256 is divisible by 4. ## Explanation Marbelous is a 2D programming language, which simulates "marbles" (byte values) falling through a bunch of devices. The board is made up of 2-character wide cells (the devices), which can process the marbles. Everything that falls off the bottom of a board is printed to STDOUT. Let's go through the devices in use: * `}0` is where the first command-line argument goes. I've used two instances of this device, so I get two copies of the input value (at the same time). * `^n` checks for the `n`th bit of the input marble (where `n=0` is the least significant bit), and produces `1` or `0` depending on the bit. * `=0` checks for equality with `0`. If the input marble is equal, it just drops straight through, if it isn't it is pushed to the right. * `\/` is a trash can, so it just swallows the input marble and never produces anything. * `2D` is the ASCII code of `-`, `31` is the ASCII code of `1` and `69` is the ASCII code of `i`. * The `&n` are synchronisers. Synchronisers stall a marble until all synchronisers with the same `n` hold a marble, at which point they'll all let their stored marble fall through. So in effect, what I do is to hold the three relevant characters in three synchronisers, and release those depending on how the least significant bits are set in the input. For more information, [see the spec draft](https://github.com/marbelous-lang/docs/blob/master/spec-draft.md). [Answer] # JavaScript (ES6) 29-5 = 24 Supports negative power. ``` f=n=>(n&2?'-':'')+(n&1?'i':1) ``` ES5 : ``` function f(n){return (n&2?'-':'')+(n&1?'i':1)} ``` [Answer] # [APL (Dyalog)](https://www.dyalog.com/), 8 chars - 15 bonus = score -7 The built-in (and thus prohibited) function is `0J1‚ä¢`, but this uses [@blutorange's method](https://codegolf.stackexchange.com/a/47446/43319). ``` ¬Ø12‚óã.5√ó‚óã ``` The challenge author, Kezz101, [wrote](https://codegolf.stackexchange.com/questions/41719/find-in-given-n#comment97114_41719): > > If you support any real number you can output in any valid complex form. > > > This returns a complex number in the form `aJb` which is the normal way for APL to display complex numbers. [Try it online!](https://tio.run/##SyzI0U2pTMzJT///PzMgvzy16FHbhEPrDY0eTe/WMz08HUj9dyutqoKIplpmgUltEAtEP@papPCod65CempJsUJRZopCfppCWk5@YklmXrpCQX5mXolCalFRflEx2BAFiA0KhgpGCsYKJgqmXMiiQJOB2AiIjYHYBIhR5Q30DIHYCIiNgdgEiE0B "APL (Dyalog Unicode) ‚Äì Try It Online") ### Explanation `¬Ø12‚óã`‚ÄÉfind the unit vector which has the angle in radians of `.5√ó`‚ÄÉone half times `‚óã`‚ÄÉthe argument multiplied by ùúã (the circle constant) [Answer] # Python 28 bytes - 5 = 23 Supports -ve inputs. Assuming lambda functions are acceptable (Thanks FryAmTheEggman!): ``` lambda n:n%4/2'-'+'1i'[n%2] ``` ### otherwise 31 bytes - 5 = 26 ``` print[1,"i",-1,"-i"][input()%4] ``` [Answer] # [Pari/GP](http://pari.math.u-bordeaux.fr/), 14 bytes - 5 = 9 As a ring, \$\mathbb{C}\$ is isomorphic to \$\mathbb{R}[x]/(x^2+1)\$. ``` n->i^n%(i^2+1) ``` The `i` here is just a symbol, not the imaginary unit (which is `I` in Pari/GP). [Try it online!](https://tio.run/##K0gsytRNL/ifpmCr8D9P1y4zLk9VIzPOSNtQ839afpFGHlBc19BARwGEFQqKMvNKgGJKCrp2QCJNI09TU/M/AA "Pari/GP ‚Äì Try It Online") [Answer] # (Emacs) Lisp ‚Äì 34 Just for fun, in (Emacs) Lisp: ``` (lambda(n)(elt[1 i -1 -i](% n 4))) ``` If you want to use it, use a `defun` or use `funcall`: ``` (funcall (lambda (n) (elt [1 i -1 -i] (% n 4))) 4) => 1 (mapcar (lambda(n)(elt[1 i -1 -i](% n 4))) [0 1 2 3 4 5 6 7 8]) => (1 i -1 -i 1 i -1 -i 1) ``` [Answer] # [R](https://www.r-project.org/), 29 - 5 = 24 bytes ``` c(1,"i",-1,"-i")[scan()%%4+1] ``` [Try it online!](https://tio.run/##K/r/P1nDUEcpU0lHF0jpZippRhcnJ@ZpaKqqmmgbxv435DLiMuYy4TLlMuMy57Lg@g8A "R ‚Äì Try It Online") Same as most methods above, takes a modulo of 4, and increases that by 1, because R's arrays are 1-indexed. Works for negative integers as well. I was worried about mixed outputs here, but Giuseppe pointed out that R coerces numeric types to string types when they are mixed. [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 28 bytes -5 = 23 ``` ('i',-1,'-i',1)["$args"%4-1] ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkmZb/V9DPVNdR9dQR10XSBtqRiupJBalFyupmugaxv6v5eLSNTTQ0zM0qFGtVlKJV7BSUNFQU0lTUInXVKr9DwA "PowerShell ‚Äì Try It Online") Port of all the cyclic indexing [Answer] # Pure bash, 29 bytes - 5 = 24 Supports -ve inputs. ``` a=(1 i -1 -i) echo ${a[$1%4]} ``` [Answer] # Befunge-98, ~~41-5 = 36~~ ~~35-5 = 30~~ 32-5 = 27 ``` &4%:01-`!4+:2%'8'1+\2/d' +,,@ ``` Supports negative integers. Not going to win any awards with this solution, but whatever. It just accepts a number as input, does some trickery on the modulus (which, frustratingly, doesn't work like usual modulus for negative numbers in the interpreter I used to test it) to make negatives work, and then does some silly conditionals to decide what each character should be. I'm sure this can be golfed down plenty further. For now, here's another solution that doesn't accept negatives, but makes up for the loss of the bonus by being shorter: # Befunge-98, ~~32~~ ~~26~~ 23 ``` &4%:2%'8'1+\2/d' +,,@ ``` Edit* - Now takes advantage of the fact that "-" is 13 (0xd) characters away from " ". Edit 2 - Now, again, takes advantage of the fact that "i" is 56 (0x38, or `'8`) characters away from "1". [Answer] # Java: ~~151~~ 131-5=126 Golfed: ``` class A{public static void main(String[]a){int n=Integer.parseInt(a[0]);System.out.print(n%4==0?"1":n%4==1?"i":n%4==2?"-1":"-i");}} ``` Ungolfed: ``` class A { public static void main(String[] a) { int n = Integer.parseInt(a[0]); System.out.print(n % 4 == 0 ? "1" : n % 4 == 1 ? "i" : n % 4 == 2 ? "-1" : "-i"); } } ``` ### As a function: 72-5=67 Golfed: ``` void f(int n){System.out.print(n%4==0?"1":n%4==1?"i":n%4==2?"-1":"-i");} ``` Ungolfed: ``` public void f(int n) { System.out.print(n % 4 == 0 ? "1" : n % 4 == 1 ? "i" : n % 4 == 2 ? "-1" : "-i"); } ``` Yes, yet another Java reply - and golfed even worse than ever. But you work with what you can... *EDIT: added function version. EDIT 2: so, after a bit of trial and error, here's a version that tries to do it by the book, without exploring the cycle loophole. So‚Ä¶ ### Java with value calculation: 146-15=131 Golfed: ``` class B{public static void main(String[]a){float n=Float.parseFloat(a[0]);System.out.print(Math.cos((nMath.PI)/2)+Math.sin((nMath.PI)/2)+"i");}} ``` Ungolfed: ``` class B { public static void main(String[] a) { float n = Float.parseFloat(a[0]); System.out.print(Math.cos((n Math.PI) / 2) + Math.sin((n * Math.PI) / 2) + "i"); } } ``` (at least, I think I can claim the top bonus, correct me otherwise) [Answer] # Java 8 Score: 72 In Java, the worst golfing language ever! Golfed: ``` java.util.function.Function s=n->{new String[]{"i","-1","-i","1"}[n%4]}; ``` Expanded: ``` class Complex{ java.util.function.Function s = n -> {new String[]{"i","-1","-i","1"}[n%4]}; } ``` Note: I'm not used to Java 8. I also do not have the runtime for it yet. Please tell me if there are any syntax errors. This is also my first golf. Edit: Removed `import`. Edit: Removed class declaration. Another answer with score = 87 - 15 = 72 ``` java.util.function.Function s=n->{Math.cos(nMath.PI/2)+"+"+Math.sin(nMath.PI/2)+"i"}; ``` Expanded: ``` class Complex{ java.util.function.Function s = n -> {Math.cos(n * Math.PI/2) + " + " + Math.sin(n * Math.PI/2) + "i"}; } ``` [Answer] # MATLAB, 33 bytes - 5 = 28 ``` x={'i','-1','-i','1'};x(mod(n,4)) ``` Even though it's a few bytes more (37-5=32), I actually like this approach better: ``` x='1i -';x((mod([n/2,n],2)>=1)+[3,1]) ``` [Answer] # C 77 ``` main(){int n;scanf("%d",&n);char c[]={n%4>1?'-':' ',~n%2?'1':'i',0};puts(c);} ``` Improved thanks to Ruslan # C 74-5=69 Oh and of course the most obvious approach ``` main(){unsigned n,c[]={"1","i","-1","-i"};scanf("%d",&n);puts(c[n%4]);} ``` [Answer] # OCaml 47 ``` let m n=List.nth["1";"i";"-1";"-i"](n mod 4);; ``` Not an award winning solution, but this is my first time code-golfing, so I'm not exactly sure of what I'm doing. I tried to use pattern matching, but that got me over 58. [Answer] # [Arn](https://github.com/ZippyMagician/Arn), [13 bytes](https://github.com/ZippyMagician/Arn/wiki/Carn) - 5 = 8 ``` ‚óÑ≈°<f5¬Æ‚Ä¶‚îò‚î§√Ø\√é¬± ``` [Try it!](https://zippymagician.github.io/Arn?code=WzEiaSJuXzEiLWkiXT8lNA==&input=LTQKLTMKLTIKLTEKMQoyCjMKNA==) # Explained Unpacked: `[1"i"n_1"-i"]?%4` ``` [ Begin sequence 1 Literal one "i" String n_ Negate 1 "-i" ] End sequence ? Indexed by _ Variable initialized to STDIN; implied % Modulo 4 Literal four ``` [Answer] # [Scala](http://www.scala-lang.org/), 7 bytes - 15 = -8 Port of [@blutorange's](https://codegolf.stackexchange.com/users/26465/blutorange) devious [Ruby answer](https://codegolf.stackexchange.com/a/47446/95792). Go upvote that! ``` 1->_90 ``` [Try it online!](https://tio.run/##K05OzEn8n5@UlZpcouCbmJmnkFpRkpqXUqzgWFCgUM1VlpijkGal4JSZ7pKanJkL5NnaKWh45pXoIIQ0FWz/G@raxWtZGvwvKMrMK8nJ00jTMNTU5ELwjFB4uYklGXoBmShiuqZAbu1/AA "Scala ‚Äì Try It Online") Takes a `BigDecimal` as input, outputs `(Int,BigDecimal)`, but honestly, you could make it work for any type with a `` method. ## Crazier solution, 3 bytes - 15 = -12 ``` 90 ``` [Try it online!](https://tio.run/##Vcm9CsIwFMXxvU9xxlbUquCgoiC4Cg6@wG1zQyNpEpLrB4jPHh1E7HZ@559aspR9c@FWcCTjwA9hpxL2IeBZ3MhCr3Hw18YytrvfyqvZKG9Q12ePxIEiCcMIdPQ9QjROrBvDeYFjVqzgpeN4N4mLby11Oa@qPy0G6km66ckMvsnyw1d@Aw "Scala ‚Äì Try It Online") First component is assumed to be 1, so it only returns the second. ## Boring solution, ~~30~~ 27 bytes ``` " 1 i-1-i"drop _%42 take 2 ``` [Try it online!](https://tio.run/##DctBCsIwEAXQfU/xKQiJEGiKK7EFly668gAytomMhiSkQxHEs0ff/q0zBarp/nSzYCKOcG9xcVlxzhmfZqMAf8QlCoYRVykcHxhqCws21nC7lJRx2x32PYReDn31qUAxTgYdJMF2GvnfJETlFWvdfOsP "Scala ‚Äì Try It Online") [Answer] # [Husk](https://github.com/barbuz/Husk), (30 bytes - 15) = 15 ``` m‚ÇÅm1.57·π†e-1 Œ£zƒ∞_m¬ß/Œ†`^‚Å∞‚Üë99ƒ∞1 ``` [Try it online!](https://tio.run/##AUYAuf9odXNr/20oLzEwMMO3MSoxMDAp4oKB/23igoJtKjEuNTfhuaBlLTEKzqN6KsSwX23Cpy/OoGBe4oGw4oaROTnEsDH///81 "Husk ‚Äì Try It Online") (The header in TIO rounds the rational number output into a fraction with maximum 3-digit numerator & demominator, for readability) Calculations with real numbers are a bit ticky in [Husk](https://github.com/barbuz/Husk), since it doesn't have any trigonometric functions. So here I implement -sin(x) as `Œ£zƒ∞_m¬ß/Œ†`^‚Å∞‚Üë99ƒ∞1` (99 iterations of the [Taylor series](https://en.wikipedia.org/wiki/Sine#Series_definition)), and use `1.57` as a very rough approximation for pi/2. To make matters even more difficult, [Husk](https://github.com/barbuz/Husk) natively outputs rational numbers as fractions, rather than decimals. So there aren't any 'floating point' inaccuracies (but there are, of course, inaccuracies!). The byte-count to round-away the (non-floating-point) inaccuracies for integer inputs is currently not included in the score. Add [+10 bytes](https://tio.run/##AUEAvv9odXNr//9tyK8vMTDDtzEqMTBt4oKBbSoxLjU34bmgZS0xCs6jeirEsF9twqcvzqBgXuKBsOKGkTk5xLAx////NQ) to include it. [Answer] # [Husk](https://github.com/barbuz/Husk), (~~14~~ 11 bytes - 5) = 6 Edit: -3 bytes thanks to Razetime ``` !C2¬®¬π-1-i 1 ``` [Try it online!](https://tio.run/##yygtzv6f@6ip8b@is9GhFYd26hrqZioY/v//P1rXSEfXUMdAx1DHSMdYxyQWAA "Husk ‚Äì Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), score 5 (10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) - 5 bonus) ``` 1'i¬Æ‚Äû-i)I√® ``` [Try it online](https://tio.run/##yy9OTMpM/f/fUD3z0LpHDfN0MzU9D6/4/1/XEAA) or [verify some more test cases](https://tio.run/##yy9OTMpM/R@iEXJ0R1mlvZLCo7ZJCkr2/w3VMw@te9QwTzdTs/Lwiv86/wE). Explanation: ``` 1 # Push 1 'i '# Push character "i" ¬Æ # Push -1 ‚Äû-i # Push string "-i" ) # Wrap everything on the stack into a list: [1,"i",-1,"-i"] I√® # Use the input to (modular 0-based) index into it # (and output the result implicitly) ``` [Answer] # Ruby 32-5=27 ``` puts(%w[1 i -1 -i][gets.to_i%4]) ``` Works for negative powers! [Answer] ## Perl, 26 - 5 = 21 ``` say qw(1 i -1 -i)[pop()%4] ``` works as a standalone program (argument on the commandline) or the body of a function. [Answer] ## Python - 31 ``` print[1,'i',-1,'-i'][input()%4] ``` I have only recently started learning python. Even though I know it's not good, it's the best I can do. [Answer] # Haskell GHCi, 29 Bytes - 15 = 14 ``` i p=[cos(ppi/2),sin(ppi/2)] ``` Usage: ``` Main> i 0 [1.0,0.0] Main> i pi [0.22058404074969779,-0.9753679720836315] Main> i (-6.4) [-0.8090169943749477,0.5877852522924728] ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 2 - 20 = -18 bytes ``` ƒ± ``` [Try it online!](https://tio.run/##y0rNyan8///IRq3///@b6hkDAA "Jelly ‚Äì Try It Online") It doesn't use an `i ^ x` builtin but it uses builtins for `1j` and `**` so not sure if allowed. [Answer] ## Swift, 27 ``` {["1","i","-1","-i"][$0%4]} ``` [Try it online](https://tio.run/##Ky7PTCsx@Z@TWqKQbKWg4ZlXoqmga6cQXFKUmZeuYPu/OlrJUElHKROIdUEM3Uyl2GgVA1WT2Nr/GgZ6enqGBpp6aflFronJGQrVCgVAbSUayRoqBpqaCrX/AQ) ]
[Question] [ Your task is to create a program that prints "Greetings, Planet!" exactly to the console. Seems simple enough, right? Well, here's the trick. The code must be a palindrome, meaning it reads from right to left the same as in left to right. Standard loopholes are *NOT* allowed. [Answer] # [///](http://esolangs.org/wiki////), 37 bytes ``` Greetings, Planet!/!tenalP ,sgniteerG ``` [Answer] # TI-BASIC, 67 bytes ``` "!tenalP ,sgniteerG" "Greetings, Planet!" ``` This works because the last line of a program is displayed on the screen, while the first string is essentially treated as a comment. Each lowercase letter is stored as 2 bytes, and the remaining characters are 1 byte. If I were to bend the rules and print in all caps, it would be 41 bytes: ``` "!TENALP ,SGNITEERG" "GREETINGS, PLANET!" ``` [Answer] I know this is a bit late (and a bit finicky), but... ## [><>](http://esolangs.org/wiki/Fish) (Fish), ~~47~~ ~~45~~ 47 Bytes (really ~~43~~ 45, if I wasn't using the randomized direction) ``` x"!tenalP ,sgniteerG"!\|o\|!"Greetings, Planet!"x ``` These answers are a bit different to every other; there is a chance for either direction of code to be executed. So, by "printing to console", I assumed you meant printing to stdout. This throws an error; the error is thrown to stderr AFTER the string is printed to stdout. To prove that this worked both ways, I used the "random direction" director, "x". Fish is a two-dimensional language, so, no matter which way the director points, the code will still (eventually) be executed. Assuming that the first director points to the right, the characters are loaded to the "stack" in reverse order, then the reverse of the reverse (or the normal text) is printed. Assuming that both directors point to the left, the characters are, once again, loaded to the "stack" in reverse order (because the code loads it in backwards here, direction is to the left), then the reverse of the reverse (or the normal text) is printed. If the randomized director points up or down, this won't matter - fish knows to loop to the underside or overside of the code, pointing back to the randomizer. In this way, it will continue to loop with the randomizers until it points inward, towards the code to execute. The `!\|o\|!` bit does the following, from both sides: * `!` skips the next instruction (will always skip `\|`) * `\|` is a reflector; it points inward back towards `o`. * `o` outputs the current item of the stack to console as a character and removes it from the stack. So, essentially, this is the "two mirrors in a bathroom pressed up together" trick, where I output until I can't anymore. ~~Now using a cat emoji. `>o<` redirects the output inward infinitely, still throwing the error, but I can get away with not using a skip into reflection.~~ Turns out I was right the first time - the second attempt was not palindromic, but it was reflective. ## Fish (without printing to stderr), 64 Bytes (ew) ``` x"!tenalP ,sgniteerG"!;oooooooooooooooooo;!"Greetings, Planet!"x ``` This dude's a little longer. It has the same randomized arrow function (to prove it works both ways) and does not print to stderr. The difference here is obvious; I literally print out every item in the stack, then end execution with `;`. The `!;` does not end execution immediately, as `!` skips the next item (end exec, in this case) and continues until it hits the other side, which acts as `;!`, wherein it ends execution before it skips anything. It follows the same randomized direction pattern as the shorter answer. [Answer] # [Bubblegum](https://esolangs.org/wiki/Bubblegum), 38 bytes ``` 0000000: 73 2f 4a 4d 2d c9 cc 4b 2f d6 51 08 c8 49 cc 4b 2d 51 04 s/JM-..K/.Q..I.K-Q. 0000013: 04 51 2d 4b cc 49 c8 08 51 d6 2f 4b cc c9 2d 4d 4a 2f 73 .Q-K.I..Q./K..-MJ/s ``` [Answer] ## [Macaroni 0.0.2](https://github.com/KeyboardFire/macaroni-lang/releases/tag/v0.0.2-alpha), 52 bytes ``` print "Greetings, Planet!""!tenalP ,sgniteerG" tnirp ``` A solution that doesn't use comments. (Mostly because Macaroni doesn't have comments...) [Answer] # CJam, 41 bytes Thanks to Dennis for the three bytes off. ``` "!tenalP ,sgniteerG";"Greetings, Planet!" ``` [Answer] # Foo, 39 bytes ``` "Greetings, Planet!"!tenalP ,sgniteerG" ``` [Try it online.](http://foo.tryitonline.net/#code=IkdyZWV0aW5ncywgUGxhbmV0ISIhdGVuYWxQICxzZ25pdGVlckci&input=) [Answer] # JavaScript, 56 bytes This can run in any browser. ``` alert("Greetings, Planet!")//)"!tenalP ,sgniteerG"(trela ``` [Answer] # C++, 129 bytes Trying to do this without comments led me into a deep, dark preprocessor nightmare with no way out that I could see. Instead I've just aimed to get it as short as possible. ``` /*/ #include<cstdio> int main(){puts("Greetings Planet!");}/// ///};)"!tenalP sgniteerG"(stup{)(niam tni >oidtsc<edulcni# // ``` [Answer] # Jelly 25 bytes* ``` »1ị“RsẈḄ,#ʠU“Uʠ#,ḄẈsR“ị1» ``` Look 'ma, no comments! [Try it online!](http://jelly.tryitonline.net/#code=wrsx4buL4oCcUnPhuojhuIQsI8qgVeKAnFXKoCMs4biE4bqIc1LigJzhu4sxwrs&input=) ### How it works ``` »1ị“RsẈḄ,#ʠU“Uʠ#,ḄẈsR“ị1» Main link. No arguments. “ “ “ » Decompress all three strings; yield a list of strings. RsẈḄ,#ʠU (decompresses to 'Greetings, Planet!') Uʠ#,ḄẈsR (decompresses to ' WafdkmC Posited,') ị1 (decompresses to 'Taarhus') »1 Take the maximum of the default argument (0) and 1. ị Select the string at the index to the left. ``` [Answer] # GolfScript, 41 bytes ``` "Greetings, Planet!":"!tenalP ,sgniteerG" ``` Look ma, no no-ops! Try it online in [Web GolfScript](http://golfscript.apphb.com/?c=IkdyZWV0aW5ncywgUGxhbmV0ISI6IiF0ZW5hbFAgLHNnbml0ZWVyRyI%3D). The second half of the source code stores the string in the second string. ``` "Greetings, Planet!":"!tenalP ,sgniteerG" "!tenalP ,sgniteerG" ``` would print ``` Greetings, Planet!Greetings, Planet! ``` [Answer] ## Python 3, 57 bytes ``` print('Greetings, Planet!')#)'!tenalP ,sgniteerG'(tnirp ``` I fixed the issue with parenthesis. ## Python 2, 53 bytes ``` print'Greetings, Planet!'#'!tenalP ,sgniteerG'tnirp ``` I used advantage of the lack of required parenthesis and spaces in Python 2, but there wasn't that big of a difference. [Answer] # [Stuck](http://esolangs.org/wiki/Stuck), 41 Bytes ``` "Greetings, Planet!"p"!tenalP ,sgniteerG" ``` Fairly similar to the CJam answer, except in Stuck if a print command is issued, automatic stack printing is suppressed. [Answer] # [05AB1E](http://github.com/Adriandmen/05AB1E), 16 bytes Code: ``` ”!º¥,ÁÙ””ÙÁ,¥º!” ``` Explanation: ``` ”!º¥,ÁÙ” # Compressed string which results in "! Crm, Everywhere". ”ÙÁ,¥º!” # Compressed string which results in "Greetings, Planet!". # Top of stack is implicitly outputted. ``` [Try it online!](http://05ab1e.tryitonline.net/#code=4oCdIcK6wqUsw4HDmeKAneKAncOZw4EswqXCuiHigJ0&input=MjI) [Answer] ## Mathematica, 52 bytes ``` Print@"Greetings, Planet!""!tenalP ,sgniteerG"@tnirP ``` Also generates a `Null "!tenalP ,sgniteerG"[tnirP]` which doesn't get printed. [Answer] ## [Fission](https://github.com/C0deH4cker/Fission), ~~45~~ 43 bytes Thanks to jimmy23013 for saving 2 bytes. ``` ;"!tenalP ,sgniteerG"R"Greetings, Planet!"; ``` [Try it online!](http://fission2.tryitonline.net/#code=OyIhdGVuYWxQICxzZ25pdGVlckciUiJHcmVldGluZ3MsIFBsYW5ldCEiOw&input=) `R` initialises an atom which moves to the right. `"` toggles string mode which simply prints the desired string to STDOUT before hitting `;`, which destroys the atom and terminates the program. The first half is simply never executed. [Answer] ## STATA, 52 bytes `di "Greetings, Planet!"//"!tenalP ,sgniteerG" id` A slightly longer (53 byte) version that doesn't use comments is: ``` #d di "Greetings, Planet!";"!tenalP ,sgniteerG" id d# ``` `#d [something]` changes the delimiter (initially a carriage return) to `;` unless [something] is `cr`, so the first command changes the delimiter to `;`, the second prints the string, and the third (which continues until the end) is apparently a nop, though I have no idea why. I would have guessed that this would throw an error (unrecognized command "!tenalP ,sgniteerG" or something), but apparently not. [Answer] # [Japt](https://github.com/ETHproductions/Japt), 29 bytes This programming language was made after the question was posted, but was not made for this question. ``` `!t?ÓP ,?Ä>ÎG`;`GÎ>Ä?, PÓ?t!` ``` [Try it online!](http://ethproductions.github.io/japt?v=master&code=YCF0gtNQICwPxD7OR2A7YEfOPsQPLCBQ04J0IWA=&input=) Each `?` is an unprintable Unicode char: U+0082, U+000F, U+000F, and U+0082, respectively. Fun fact: If Japt had been published a month sooner, it would have legitimately won this challenge. [Answer] ## APL, 41 bytes ``` 'Greetings, Planet!'⍝'!tenalP ,sgniteerG' ``` In APL, the last value is printed and the lamp character (⍝) start a comment. [Answer] ## [GolfScript](https://esolangs.org/wiki/GolfScript), 41 bytes ``` "Greetings, Planet!"#"!tenalP ,sgniteerG" ``` [Try it online !](https://golfscript.apphb.com/?c=IkdyZWV0aW5ncywgUGxhbmV0ISIjIiF0ZW5hbFAgLHNnbml0ZWVyRyI%3D) [Answer] # TCL, 80 Bytes ``` proc unknown args {puts "Hello World!"} }"!dlroW olleH" stup{ sgra nwonknu corp ``` explanation: TCL executes a global proc `unknown` when it encounters a call to an undefined command, the first line redefines that proc to a simple "hello world" program. TCL's quoting rules are quite subtle, an open brace starts a quoted word that extends to the next matching close brace, allowing nested, quoted words. Braces are otherwise treated as normal characters. five words: `}"!dlroW olleH"`, `stup{`, `sgra`, `nwonknu` and `corp`. No command named `}"!dlroW olleH"` has been defined, so the `undefined` proc from the first line is invoked instead. A similar question was posted on the StackOverflow of antiquity; which has since been closed and deleted. I used my solution as a tongue in cheek TCL sample in [this answer](https://stackoverflow.com/a/1004513/65696), and am now getting comments asking for an explanation, so I recreate my answer here. [Answer] ## [Keg](https://esolangs.org/wiki/Keg), 41 bytes ``` Greetings\, Planet\!#!\tenalP ,\sgniteerG ``` [Try it online!](https://tio.run/##y05N///fvSg1tSQzL704RkchICcxL7UkRlFZMaYkNS8xJ0BBJ6Y4PS@zJDW1yP3/fwA) [Answer] # [Vitsy](https://github.com/VTCAKAVSMoACE/Vitsy), 41 Bytes This programming language was made after the question was posted, but was not made for this question. ``` "!tenalP ,sgniteerG"Z"Greetings, Planet!" ``` The `Z` character outputs everything in the stack to STDOUT. [Try it online!](http://vitsy.tryitonline.net/#code=IiF0ZW5hbFAgLHNnbml0ZWVyRyJaIkdyZWV0aW5ncywgUGxhbmV0ISI&input=) [Answer] # Unefunge 98 - 49 bytes ``` "!tenalP ,sgniteerG<DC1>"k,@,k"<DC1>Greetings, Planet!" ``` The code above contains two unprintable characters with code 17 (device control 1) represented by `<DC1>`. [Answer] ## [MSM](http://esolangs.org/wiki/MSM), 73 bytes ``` GGreetings, Planet!.................,.................!tenalP ,sgniteerGG ``` The first half just before the middle `,` builds a reverse greeting string including the additional `G` on the very right. The middle `,` drops it and the rest is a canonical "Hello/Greeting/whatever" program. The additional characters on both ends are needed, because the message contains a `,`. The left one is executed and drops the `s`. Both `,` and `s` need a replacement for the left concatenation dots, hence the `G`s. The `,` on the right isn't executed, but build into the final string. [Answer] ## CoffeeScript, 53 bytes Similar to Ruby and Lua and pretty much all the variants here. ``` alert 'Greetings, Planet!'#'!tenalP ,sgniteerG' trela ``` [Answer] # Ruby, 43 bytes ``` p"Greetings, Planet!"#"!tenalP ,sgniteerG"p ``` [Answer] ## Bash, 52 48 bytes ``` echo Greetings, Planet!\|\|!tenalP ,sgniteerG ohce ``` Also works in ksh, zsh, yash, dash. But not tcsh. ``` $ cat x.sh echo Greetings, Planet!\|\|!tenalP ,sgniteerG ohce $ bash x.sh Greetings, Planet! $ ksh x.sh Greetings, Planet! $ zsh x.sh Greetings, Planet! $ yash x.sh Greetings, Planet! $ dash x.sh Greetings, Planet! $ tcsh x.sh tenalP: Event not found. $ ``` [Answer] # Lua, 52 Bytes ``` print"Greetings, Planet!"--"!tenalP ,sgniteerG"tnirp ``` In Lua terminal, it is only 44 bytes with ``` ="Greetings, Planet!"--"!tenalP ,sgniteerG"= ``` [Answer] # [Milky Way 1.5.10](https://github.com/zachgates7/Milky-Way), ~~43~~ ~~41~~ 39 bytes ``` "Greetings, Planet!"!tenalP ,sgniteerG" ``` --- ### Explanation ``` "Greetings, Planet!" # push the string to the stack ! # output the TOS tenalP ,sgniteerG" # throws an error and exits ``` --- ### Usage ``` python3 milkyway.py <path-to-code> ``` ]
[Question] [ ## The Challenge Given a string, output the text in the shape of a square. You can assume that the text will always fit in a [square](https://oeis.org/A000290), and that it will never be an empty string. You can also assume it will never have newlines. ### Example ``` Input: Hi, world Output: Hi, wo rld ``` ## Test Cases ``` Input: Hi, world! Hello Output: Hi, worl d! H ello Input: Lorem ipsum dolor sit amt Output: Lorem ipsu m dol or si t amt Input: H Output: H ``` ## Rules * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins! Tiebreaker is most upvoted answer. * Standard loopholes are forbidden. [Answer] # Vim, ~~59, 57~~, 48 bytes/keystrokes ``` $:let @q=float2nr(sqrt(col('.')))."\|li<C-v><cr><C-v><esc>@q"<cr>@q ``` Since V is backwards compatible, you can [Try it online!](https://tio.run/nexus/v#@69ilZNaouBQaJuWk59YYpRXpFFcWFSikZyfo6Gup66pqamnVJOTKcYlJu1QqMTlUPj/v09@UWquQmZBcWmuQkp@Tn6RQnFmiUJibsl/3TIA "V ‚Äì TIO Nexus") I randomly received an upvote on this answer, so I looked over it again. My vim-golfing skills have greatly increased over the last 7 months, so I saw that this answer was very poorly golfed. This one is much better. [Answer] # [Brainfuck](http://esolangs.org/wiki/Brainfuck), ~~116~~ 112 bytes ``` >>>>,[[<]<<+>>>[>],]<[<]<+<[>>+<[-<-<+>>]<<++[->>+<<]>]>[-]>>[<[->.[-]<[->+<]<+[->+<]>>]++++++++++.[-]<[->+<]>>] ``` [Try it online!](http://brainfuck.tryitonline.net/#code=Pj4-LFs-LF08W1stPis8XTxbPF08Kz4-Wz5dPF0rPFs-Pis8Wy08LTwrPj5dPDwrK1stPj4rPDxdPl0-Wy1dPj5bPFstPi5bLV08Wy0-KzxdPCtbLT4rPF0-Pl0rKysrKysrKysrLlstXTxbLT4rPF0-Pl0&input=YWJjZGVmZ2hp) Safe in flavours of BF that does not mask the cells with `256`, does not support null bytes. Remove the initial right arrows if the flavour supports negative memory for 4 bytes saved. ## Explanation The program is divided into 3 stages: ``` Stage 1: >>>>,[[<]<<+>>>[>],]<[<] Stage 2: <+<[>>+<[-<-<+>>]<<++[->>+<<]>]>[-]>> Stage 3: [<[->.[-]<[->+<]<+[->+<]>>]++++++++++.[-]<[->+<]>>] ``` ### Stage 1 In this stage, we put all the characters onto the tape, while keeping count of the number of characters. This is the tape for the input `abcdefghi` after this tape: ``` 000 009 000 000 095 096 097 098 099 100 101 102 103 ^ ``` The `009` is the count. For each character, we move the the first zero on the left `[<]` and then add one to the count `<<+>>>`, and then move to the rightmost zero `[>]` to get ready for the next character. ## Stage 2 This stage does the square root of the length stored in the second cell. It keeps subtracting by `1, 3, 5, 7, ...` until the number reaches zero, while keeping check of the number of iterations. It works because square numbers can be expressed as `1 + 3 + 5 + ...`. ## Stage 3 Denote the square root of the length found above as `n`. This stage outputs `n` characters at a time, and then output a newline, until the tape is cleared. [Answer] ## Python 2, 55 bytes ``` s=input() n=int(len(s).5) while s:print s[:n];s=s[n:] ``` [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes ``` Dgt√¥¬´ ``` [Try it online!](http://05ab1e.tryitonline.net/#code=RGd0w7TCqw&input=TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtdAo) ``` D duplicate a (implicit input) g length of a t square root of a √¥ push a split in pieces of b ¬´ join by newlines (implicit output) ``` [Answer] # [MATL](https://github.com/lmendo/MATL), 6 bytes ``` tnX^e! ``` [Try it online!](http://matl.tryitonline.net/#code=dG5YXmUh&input=J0hpLCB3b3JsZCEgSGVsbG8n) ### Explanation ``` t % Take input implicitly. Push another copy n % Get number of elements of the copy X^ % Take square root e % Reshape the input into that number of rows, in column-major order % (which means: down, then across) ! % Transpose so that text reads horizontally. Implicitly display ``` [Answer] # Jelly, ~~8~~ 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` sL√Ü¬Ω$j‚Å∑ ``` Saved a byte thanks to @[Dennis](https://codegolf.stackexchange.com/users/12012/dennis). [Try it online.](http://jelly.tryitonline.net/#code=c0zDhsK9JGrigbc&input=&args=J0xvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbXQn) ## Explanation ``` sL√Ü¬Ω$j‚Å∑ Input: string S $ Monadic chain L Get the length of S √Ü¬Ω Take the integer square root of it, call it n s Split S into chunks of size n j‚Å∑ Join using newline ``` [Answer] ## JavaScript (ES7), 49 bytes ``` s=>s.match(eval(`/.{${s.length.5}}/g`)).join` ` ``` 44 bytes in Firefox Nightly 43-46 only (`` was introduced some time between Firefox Nightly 42 and 43 and `g` as a separate parameter was removed some time between Firefox Nightly 46 and 47): ``` s=>s.match(`.{${s.length.5}}`,`g`).join` ` ``` [Answer] # J, 9 bytes ``` $~,~@%:@# ``` This is a monadic hook over the input string: ``` $~ ,~@%:@# ``` The right tine is a series of compositions: ``` ,~ @ %: @ # ``` The left is a shaping verb, switched such that it works in the hook format. Here are some intermediate results: ``` # 'hiya' 4 %:@# 'hiya' 2 ,~@%:@# 'hiya' 2 2 ``` In words: ``` size =: # sqrt =: %: dup =: ,~ on =: @ shape =: $~ block =: shape dup on sqrt on size block 'Hello, World! :)' Hell o, W orld ! :) ``` [Answer] # C, 64 bytes Call `f()` with the string to square. ``` m;f(chars){for(m=sqrt(strlen(s));s;s+=m)printf("%.s\n",m,s);} ``` [Try it on ideone](http://ideone.com/bQlPa9). [Answer] ## Perl, 23 + 4 (`-pF` flags) = 27 bytes -2 bytes thanks to [@DomHastings](https://codegolf.stackexchange.com/users/9365/dom-hastings)* -1 bytes thanks to [@DomHastings](https://codegolf.stackexchange.com/users/9365/dom-hastings) ``` $==sqrt@F;s/.{$=}/$& /g ``` [Try it online!](https://tio.run/##BcGxCgIxDADQPV8RoTipnZyk4HR08Cd6XJVCamqSQ1Du143vjSp0dg8p6UvsOl00nr4hbTHsIT7cM1hVgzvzXGQuH8jtgG8WWnaYKxHDjaV2bEPXjgsTC2ozLN1@PKzxU/04pj8 "Perl 5 ‚Äì Try It Online") Expanations : computes the square root (lets call it `S` for the explanation) of the size of the input (it will be always be an integer) (`@F` is used in scalar context, thus returning its size), then add a newline after each bloc of `S` characters. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), ~~8~~ 6 bytes Thanks to @quartata for letting me know about the square-root function ``` Dgt√¥¬∂√Ω ``` [Try it online!](http://05ab1e.tryitonline.net/#code=RGd0w7TCtsO9&input=TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtdA) ### Explanation ``` D Implicit input. Duplicate g Number of elements t Square root √¥ Split into chunks of that length ¬∂ Push newline character √Ω Join list by newlines. Implicit display ``` [Answer] # Dyalog APL, 10 bytes ``` ‚ä¢‚ç¥‚ç®2‚ç¥.5‚ç®‚â¢ ``` Explanation: ``` ‚â¢ length of the argument .5‚ç® square root 2‚ç¥ reshape that to a length-2 vector ‚ä¢‚ç¥‚ç® reshape the input by that vector ``` Tests: ``` (‚ä¢‚ç¥‚ç®2‚ç¥.5‚ç®‚â¢)'Hi, world' Hi, wo rld (‚ä¢‚ç¥‚ç®2‚ç¥.5‚ç®‚â¢)'Hi, world! Hello' Hi, worl d! H ello (‚ä¢‚ç¥‚ç®2‚ç¥.5‚ç®‚â¢)'Lorem ipsum dolor sit amt' Lorem ipsu m dol or si t amt (‚ä¢‚ç¥‚ç®2‚ç¥.5‚ç®‚â¢) 'H' H ``` [Answer] # Python, ~~94~~ ~~75~~ ~~71~~ ~~65~~ 63 bytes ``` import re;lambda r:"\n".join(re.findall("."int(len(r).5),r)) ``` Old version: ``` lambda r:"\n".join(map("".join,zip([iter(r)]int(len(r).5)))) ``` [Answer] ## zsh, ~~36~~ 33 bytes ``` fold -`tr -d .<<<$[$#1.5]`<<<$1 ``` [Try it online!](https://tio.run/##qyrO@P8/LT8nRUE3oaRIQTdFQc/GxkYlWkXZUEtLzzQ2AcQz/P//v09@UWquQmZBcWmuQkp@Tn6RQnFmiUJibgkA) Takes input as a command line argument, outputs to STDOUT. ``` $#1 # get the length of the input string $[ .5] # take it to the .5 power (sqrt) <<< # and pass the result to tr -d . # tr, to delete the trailing decimal point # (sqrt(9) is 3. instead of 3) -` ` # give the result as a command line flag to fold # the fold util, which wraps at nth column <<<$1 # pass the input as input to fold ``` [Answer] # Cheddar, 27 bytes ``` s->s.chunk(s.len.5).vfuse ``` I added the `.chunk` function a while ago but I removed it in the transition to the new stdlib format and forgot to re-add it. Cheddar has a dedicated `sqrt` operator but `.5` is shorter [Try it online!](http://cheddar.tryitonline.net/#code=cy0-cy5jaHVuayhzLmxlbioqLjUpLnZmdXNl&input=SGksIHdvcmxk) ## Explanation ``` s -> // Function with argument s s.chunk( // Chunk it into pieces of size... s.len * .5 // Square root of length. ).vfuse // Vertical-fuse. Join on newlines ``` [Answer] # [CJam](https://sourceforge.net/projects/cjam/), 8 bytes ``` l_,mQ/N* ``` [Try it online!](http://cjam.tryitonline.net/#code=bF8sbVEvTio&input=SGksIHdvcmxk) ### Explanation ``` l e# Read line from input _, e# Duplicate. Get length mQ e# Integer square root / e# Split into pieces of that size N* e# Join by newline. Implicitly display ``` [Answer] # Pyth, 8 bytes ``` jcs@lQ2Q ``` [Try it online](https://pyth.herokuapp.com/?code=jcs%40lQ2Q&test_suite=1&test_suite_input=%22Hi%2C+world%22%0A%22Lorem+ipsum+dolor+sit+amt%22%0A%22H%22) ### How it works ``` lQ length of input @ 2 square root s floor c Q chop input into that many equal pieces j join on newline ``` [Answer] # Bash + GNU utilities, 25 ``` fold -`dc -e${#1}vp`<<<$1 ``` Not so different to [@Doorknob's answer](https://codegolf.stackexchange.com/a/88960/11259), but `dc` is a shorter way to get the square root. [Answer] # ùîºùïäùïÑùïöùïü, 11 chars / 14 bytes ``` —®ƒä(√Ø,‚àö √ØÍùà‚∏©ƒñ‚¨Æ ``` `[Try it here (ES6 browsers only).](http://molarmanful.github.io/ESMin/interpreter3.html?eval=false&input=asdfghjkqweruiop&code=%D1%A8%C4%8A(%C3%AF%2C%E2%88%9A%20%C3%AF%EA%9D%88%E2%B8%A9%C4%96%E2%AC%AE)` Generated using this code (run in the interpreter's browser console): ``` c.value=`—®${alias(_,'chunk')}(√Ø,‚àö √ØÍùà‚∏©${alias(Array.prototype,'mjoin')}‚¨Æ` ``` [Answer] ## Brainfuck, 83 bytes ``` ,[>+[>+<-],] > [ >>[<+<-->>-] +<[>+<-] <- ] << [ [<] >., >[>] >>+>-[<] <[[>+<-]++++++++++.,<<] < ] ``` [Try it online!](http://brainfuck.tryitonline.net/#code=LFs-K1s-KzwtXSxdPls-Pls8KzwtLT4-LV0rPFs-KzwtXTwtXTw8W1s8XT4uLD5bPl0-Pis-LVs8XTxbWz4rPC1dKysrKysrKysrKy4sPDxdPF0&input=TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtdA) This uses the same idea as Leaky Nun's [answer](https://codegolf.stackexchange.com/a/88968/2537). He asked for help golfing it in chat, then suggested that I add this as a new answer. (Actually what I wrote in chat was an 84-byte solution very similar to this.) For the sake of comparison, an extra `>` is needed at the beginning for brainfuck implementations that don't allow negative memory addresses. As expected, this finds the length of the input, then takes the square root, then prints the lines accordingly. It takes advantage of perfect squares being partial sums of `1 + 3 + 5 ...`. [Answer] # [Brain-Flak](https://github.com/Flakheads/BrainHack), ~~110~~ 96 bytes ``` ([]<>){({}{}(({}[()])))}{}{({}()<(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>)>)}{}{}{({}<>)<>}<> ``` [Try it online!](https://tio.run/##SypKzMzLSEzO/v9fIzrWxk6zWqO6trpWA0hGa2jGampqAnkgMQ1NG5Cgpg2UY2MHpIHq7TTByjU0YVATqAgqDNEJVGRjByT///@v5JGpo1CeX5STovRf1xEA "Brain-Flak (BrainHack) ‚Äì Try It Online") # Second solution, 96 bytes ``` (([]<>)<{({}({})({}[()]))}{}>){({}(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>))}{}{}{({}<>)<>}<> ``` [Try it online!](https://tio.run/##SypKzMzLSEzO/v9fQyM61sZO06Zao7oWiDSBOFpDM1ZTs7a61k4TLAoShshr2tjYAWmgejuQvIaGhiYMagIV2YF1ASFEjY0dkPz//7@SR6aOQnl@UU6K0n9dRwA "Brain-Flak (BrainHack) ‚Äì Try It Online") ## Explanation Here I explain the first solution, both are the same length but I like the first one because it is cooler and employs some nice tricks. The most important part of the code is a modified square root function I wrote some time ago. The original version was ``` {({}[({})({}())])}{} ``` And this works, but we actually want two copies of the negative square root. Why? We need two copies because we are looping through the string at two levels, one to make the lines and one to count the number of lines. We want it to be negative because looping with negatives is cheaper. To make this negative we move around the `[...]` so it looks like this ``` {({}({})({}[()]))}{} ``` To make two copies we change when pops occur ``` {({}{}(({}[()])))}{} ``` Now that we have that bit we can put it together with a stack height to get the first chunk of code we need. ``` ([]<>){({}{}(({}[()])))}{} ``` We move to the offstack because our square root function needs two free zeros for computation, and because it makes stuff a little bit cheaper int he future in terms of stack switching. Now we construct the main loop ``` {({}()<(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>)>)}{}{} ``` This is pretty straight forward, we loop n times each time moving n items and capping it with a new line (ASCII 10). Once the loop is done we need to reverse the order of our output so we just tack on a standard reverse construct. ``` {({}<>)<>}<> ``` [Answer] ## PHP, 51 bytes ``` <?=join(" ",str_split($x=$argv[1],strlen($x)*.5)); ``` [Answer] # [Perl 6](http://perl6.org), 38 bytes ``` $_=get;.put for .comb: .chars.sqrt.Int ``` ### Explanation: ``` $_ = get; # get a single line of input $_.put # print with trailing newline for # every one of the following: $_.comb: # the input split into $_.chars.sqrt.Int # chunks of the appropriate size ``` [Answer] # Cheddar, 57 bytes ``` n->(m->(\|>m).map(i->n.slice(im,im+m)).vfuse)(n.len.5) ``` Since variables are broken, I would have to pass in variables through lambda application. Also, it turns out that even if variables worked, it would still be shorter to use lambda application. ### Usage ``` cheddar> (n->(m->(\|>m).map(i->n.slice(im,im+m)).vfuse)(n.len.5))("abcd") "ab cd" ``` [Answer] ## Pyke, 5 bytes ``` l,fnJ ``` [Try it here!](http://pyke.catbus.co.uk/?code=l%2CfnJ&input=Hi%2C+world) [Answer] # Java 1.7, 110 bytes ``` void f(String s){for(int i=-1,k=(int)Math.sqrt(s.length());++i<k;)System.out.println(s.substring(ik,ik+k));} ``` [Try it!](http://ideone.com/uXbmnu) (Ideone) I tried another approach with a function returning the result as a string, but just having to declare the string and the return statement is already more expensive (byte-count-wise) than the print statement. Gotta love Java's verbosity... :) [Answer] # [R](https://www.r-project.org/), ~~59~~ 54 bytes ``` function(s)write(el(strsplit(s,'')),1,nchar(s)^.5,,'') ``` [Try it online!](https://tio.run/##Fco9CoAwDEDh3VN0awpRcHDzAJ5C8KfFQG0liYinr3V8H49LpJUXfuH0euRdXNMEM7Yl3GlTygnEPUzqwUcQZbkiKQha6xz2mLZj4brM3YC/lQB2IjRP5rjX/AA "R ‚Äì Try It Online") Prints with a trailing newline. Surprisingly short, considering how badly R handles strings. [Answer] # PowerShell, 56 ~~58~~ ~~61~~ bytes ``` param($i)$i-replace".{$([Math]::Sqrt($i.Length))}",'$& ' ``` [Answer] # [Ruby](https://www.ruby-lang.org/) `-p`, ~~40~~ ~~33~~ 30 bytes -7 bytes from @Jordan. ``` gsub(/#{?.~/$/**0.5}/){$&+$/} ``` [Try it online!](https://tio.run/##KypNqvz/P724NElDX7naXk@rTl9FX0vLQM@0Vl@zWkVNW0W/9v9/n/yi1FyFzILi0lyFlPyc/CKF4swShcTckn/5BSWZ@XnF/3ULAA "Ruby ‚Äì Try It Online") [Answer] # [K (ngn/k)](https://gitlab.com/n9n/k), 11 bytes ``` {(2#%#x)#x} ``` [Try it online!](https://tio.run/##y9bNS8/7/z/NqlrDSFlVuUJTuaL2f5qST35Raq5CZkFxaa5CSn5OfpFCcWaJQmJuidJ/AA "K (ngn/k) ‚Äì Try It Online") --- the bracketed expression returns list `5 5` for input "Lorem ipsum dolor sit amt". it reads "2 take sqrt count x", where x is the string argument. then `(5 5)#x` means "cut x into 5 lists each of length 5". with this we get: ``` {(2#%#x)#x}"Lorem ipsum dolor sit amt" ("Lorem";" ipsu";"m dol";"or si";"t amt") ``` ]
[Question] [ Task Read in a possibly infinite text stream or file, outputting its contents until the word `hello` has been output, abiding to the following rules. * Once `hello` has been output, your code should quit immediately. It should not wait for a newline for example. * Your code should output as it goes. That is it shouldn't read in a huge amount of input and then start outputting. * If the stream/file doesn't contain `hello`, your code should just carry on outputting the input forever or until the end of the stream/file is reached. * This is a case sensitive challenge, so `hello` is not equal to `Hello`. * You may assume that the input consists solely of printable ASCII characters and newlines. * Your code can't expect that the text will be terminated by a newline or that there will be any newlines at all in the input. Also, you code cannot assume that it will run on a machine with an infinite amount of memory. * You may assume that your code will be called from an empty directory. Example input stream ``` I once had a horse called hellopina. ``` Output ``` I once had a horse called hello ``` Tip Run `yes \| tr -d \\n \| <your program>` to check if it works with infinite streams. If it doesn't print anything and/or leaks memory, the program doesn't comply with the spec. It should print `yyyyyyyyyyyyyyyyyyyyyy...` forever with no newlines. [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~81~~ ~~80~~ ~~76~~ ~~75~~ ~~72~~ ~~71~~ ~~70~~ 69 bytes ``` main(n,c){while(~(c=getchar())&n-0xb33def<<7)n=n<<5^putchar(c)/96c;} ``` [Try it online!](https://tio.run/nexus/c-gcc#JclLCsJADADQq2Qlk@IPioo4PYCXENJMNAMxU6pFQfTq46Jv@@qdsgdfMn5emk3CL3B3kycrjQFx4avtu2/bJNcYD@idx7i7DNP8jJvjvuHTt9YzFGcBpQQEWsaHAJOZJFAxK0N2Wv8B "C (gcc) – TIO Nexus") ### How it works This is a full program. We define a function f* for our purposes. To save bytes, it is declared with two argument that default to int. This is undefined behavior, but in practice, n will be initialized as 1 when running the program without additional arguments, c will hold the lower 32 bits of the pointer to the argument vector While the condition ``` ~(c=getchar())&n-0xb33def<<7 ``` holds, we'll execute the while loop's body: ``` n=n<<5^putchar(c)/96c ``` To fully understand the condition, we must first examine the body. For now, all we observe is that `c=getchar()` reads a single byte from STDIN (if possible) and stores it in the variable c. The byte sequence hello* looks as follows in different representations. ``` char decimal binary (8 bits) 'h' 104 0 1 1 0 1 0 0 0 'e' 101 0 1 1 0 0 1 0 1 'l' 108 0 1 1 0 1 1 0 0 'l' 108 0 1 1 0 1 1 0 0 'o' 111 0 1 1 0 1 1 1 1 ``` All of these fall in the range [96, 192), so `c/96` will evaluate to 1 for each of these bytes, and to 0 for all remaining ASCII characters. This way, `putchar(c)/96c` (putchar* prints and returns its argument) will evaluate to c if c is ```, a lowercase letter, one of `{\|}~`, or the DEL character; for all other ASCII characters, it will evaluate to 0. n is updated by shifting it five bits to the left, then XORing the result with the result from the previous paragraph. Since an int is 32 bits wide (or so we assume in this answer), some of the shifted bits might "fall off the left" (signed integer overflow is undefined behavior, but gcc behaves as the x64 instruction it generates here). Starting with an unknown value of n, after updating it for all characters of hello, we get the following result. ``` n ?????????????????????????\|??????? 'h' \| 01101000 'e' \| 01100101 'l' \| 01101100 'l' \| 01101100 'o' \| 01101111 -----------------------------+-------------------------------- <------ discarded ------>\|???????0101100110011110111101111 ``` Note that the lower 25 bits form the integer 0xb33def, which is the magic constant in the condition. While there is some overlap between the bits of two adjacent bytes, mapping bytes below 96 to 0 makes sure that there aren't any false positives. The condition consists of two parts: * `~(getchar())` takes the bitwise NOT of the result of reading (or attempting to read) a byte from STDIN. If getchar succeeds, it will return the value of the read byte as an int. Since the input consists entirely of ASCII characters, the read byte can only have its lower 7 bits set, so the bitwise NOT will have its highest 25 bits set in this case. If getchar fails (no more input), it will return -1 and the bitwise NOT will be 0. * `n-0xb33def<<7` subtracts the magic constant from before from n, then shifts the result 7 units to the left. If the last 5 read bytes were hello, the lowest 25 bits of n will be equal to 0xb33def and the subtraction will zero them out. Shifting the difference will yield 0 as the 7 highest bits will "fall off the left". On the other hand, if the last 5 read bytes were not hello, one of the lowest 25 bits of the difference will be set; after shifting, one of the highest 25 bits will be. Finally, if getchar was successful and we didn't print hello yet, the bitwise AND, all of the highest 25 bits of the left operand and at least one of the highest 25 bits of the right one will be set. This way, `&` will yield a non-zero integer and the loop continues. On the other hand, if the input is exhausted or we have printed hello already, one of the bitwise AND's operand will be zero, and so will the result. In this case, we break out of the loop and the program terminates. [Answer] # Bash, ~~74~~ ~~75~~ ~~103~~ ~~99~~ ~~88~~ ~~82~~ 76 bytes -10 bytes thanks to @DigitalTrauma! -11 bytes thanks to @manatwork! -6 bytes thanks to @Dennis! ``` IFS= b=ppcg while [ ${b/hello} ];do read -rN1 a b=${b: -4}$a echo -n $a done ``` Explanation: ``` IFS= # making sure we can read whitespace properly b=ppcg # set the variable b to some arbitrary 4 letter string while [ ${b/hello} ]; do # while the variable b doesn't contain "hello", do the following read -rN1 a # get input b=${b: -4}$a # set b to its last 4 chars + the inputted char echo -n $a # output the inputted char done ``` [Try it online!](https://tio.run/nexus/bash#HYyxCsMwDAV3fcUbsppS6BTIWsjSpWPooNiiCgjLOEOHkm93TLaDO67Nz/dE61RK/NJPNxMsGP7rTcXMD3woOapwQqivO7in3Y4Ij2NgkqiOkNExeZbWZniOAu09Q73SLohsJgnXsGyZTw "Bash – TIO Nexus") [Answer] ## [Labyrinth](https://github.com/m-ender/labyrinth), ~~43~~ 41 bytes Thanks to Sp3000 for saving 2 bytes. ``` <_%-742302873844_::%::420#+.:%):,652_> ``` [Try it online!](https://tio.run/nexus/labyrinth#BcFBCoAgEADAryyEh6xEdEtZonuvkEUFA8mo/2MzfQ9icWisNt5ZjxiIhCRJaPQwKRIjzXJbTTh6P6HdMUPhBAylvV@GyLXmBCXX2p7rZvUD "Labyrinth – TIO Nexus") ### Explanation The basic idea is to encode the last five characters in base 256 in a single integer. When a new character comes in, we can "append" it by multiplying the integer by 256 and adding the new code point. If we want to look only at the last 5 characters, we take the value modulo 2565 = 240 = 1099511627776. Then we can simply check whether this value is equal to 448378203247, which is what we get when we treat the code points of `hello` as base-256 digits. As for the code... `<...>` is a bit of a Labyrinth idiom. It allows you to write an infinite loop without any conditional control flow on a single line, saving a lot of bytes on spaces and linefeeds. The main condition for this to work is that there are two disposable values on top of the stack when we reach the `<` (we normally use `0`s for that, but the actual value is arbitrary). Of course, the program does need some conditional logic to figure out when to terminate. But conditionally ending the program is possible by dividing by a value which is zero when we want the program to end. The `<...>` construct works by shifting the entire row left (cyclically) when the IP is at the left end, and then immediately shifting it back into position. This means that the code is actually executed right to left. Let's reverse it: ``` _256,:)%:.+#024::%::_448378203247-%_ ``` This is one iteration of the loop which reads a character, terminates if we've reached EOF, prints the character, adds it to our encoding, truncates that to 5 characters, checks for equality with `hello` and repeats. Here is how that works in detail (remember that Labyrinth is stack-based): ``` _256* Multiply the encoding by 256 in preparation for the next iteration. , Read one byte from STDIN. :)% Duplicate, increment, modulo. If we hit EOF, then , returns -1, so incrementing and modulo terminates the program due to the attempted division by zero. However, if we did read a character, we've just compute n % (n+1), which is always n itself. :. Print a copy of the character we just read. + Add it to our encoding (we'll make sure to multiply the encoding by 256 at the end of the iteration, so there's room for our new character). #024 Push 1024, using the stack depth to push the initial 1. :: Square it twice. That gives 2^40. % Take the encoding modulo 2^40 to truncate it to the last 5 characters. :: Make two copies of the encoding. _448378203247 Push the value that corresponds to "hello". - Subtract it from the encoding, giving zero iff the last 5 characters were "hello". % Take the other copy of the encoding modulo this value, again terminating if we've reached "hello". The actual value of this modulo - if it didn't terminate the the program - is junk, but we don't really care, we just need any disposable value here for the <...> _ We push a zero as the second disposable value. ``` [Answer] ## Brainfuck, 658 bytes ``` +[>,.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<,.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<,.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<,.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<,.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<<->>]]]]]<<] ``` Over 500 bytes are in the constants which I need to golf a bit. It essentially is a state machine, so infinite input is not a problem. This is the slightly commented version ``` + [ >,. >h [-<->] +< [ >-<[-][in input spot, not h] ] > [ - < [in input spot, h has been read] ,. >e [-<->] +< [ >-<[-][in input spot, not e] ] > [ - < [in input spot, e has been read] ,. >l [-<->] +< [ >-<[-][in input spot, not l] ] > [ - < [in input spot, l has been read] ,. >l [-<->] +< [ >-<[-][in input spot, not l] ] > [ - < [in input spot, l has been read] ,. >o [-<->] +< [ >-<[-][in input spot, not o] ] > [ - < [in input spot, o has been read] <->> ] ] ] ] ] << ] ``` [Answer] # [Bash](https://www.gnu.org/software/bash/), ~~73~~ ~~68~~ 66 bytes ``` IFS= [[ $1 != olleh ]]&&read -rN1 c&&echo -n $c&&exec $0 $c${1::4} ``` Assumes a directory with no or only hidden files. Must be run as `<path/to/script>`. [Try it online!](https://tio.run/nexus/bash#Lc0xC8IwEAXgOfcrnhDSQRoNOJXWUeji4lg6hEsgQkykOhTE315TdTk@Ho93bJ84QgcfY0bbotLV0p8uHQ0DpMGmQ47RB4yjUpO3DvV0NmClPIeMOkGunj1D7ovlyzTN4b1oIg637LCd/@Okdz8sPYmc2JMQwbpyhV2Zp0eJ2JZvjr7F@zVZ/QE "Bash – TIO Nexus") ### How it works (outdated) At the beginning of the while loop, we first test if the string in the variable s (initially empty) equals olleh (hello backwards, olé), and return 0 (match) or 1 (not a match) accordingly. While formally part of the loop's condition, the outcome won't affect it on its own, as only the last command before `do` determines if the condition holds. Next, we set the internal field separator to the empty string (so `read` won't choke on whitespace), read raw bytes (`-r`) from STDIN and store them in `c`. `$?` is the exit code of the previous command, so this reads exactly one (`-N1`) byte for a non-match and zero bytes (`-N0`). Reading zero bytes, whether its due to hitting EOF or because `-N0` was specified, causes `read` to exit with status code 1, so the while loop will end; otherwise, the body is executed and we start over. In the body, we first print the byte we read, then update s with `s=$c${s::4}`. This prepends the read byte to (up to) the first four bytes in s, so s will equal olleh once hello has been printed. [Answer] ## brainfuck, 117 bytes ``` --->>>------>>>+>>>+>>>++++<,[.-----<-[>--<-----]<[<<<]>>>[<[<<<+>>>>->+<<-]>[>> +>]<[+[-<<<]]>>[<+>-]>>]<[[-]<<<,<]>] ``` Formatted: ``` --->>>------>>>+>>>+>>>++++ <, [ .-----<-[>--<-----]<[<<<] >>> [ <[<<<+>>> >->+<<-] >[>>+>] <[+[-<<<]] >>[<+>-] >> ] <[[-]<<<,<] > ] ``` [Try it online](https://tio.run/nexus/brainfuck#NYtRCsAgDEOv4r9mJwi9SOnfhA4EP4end62wQEpIXzYAEcFRhPo7xKbX6QmVvCmjkrRA9KSEBVJJmGiOg6iKhCyhKvHIUmNLttja3v4U76u49zFm8fne6wM). This initializes the tape with the characters in `hello` offset by `107`, spaced out with one value every three cells, then keeps track of the last five characters seen and checks for a match with every new character processed, using a flag to the right of the string to keep track of whether there has been a match. [Answer] # [Ruby](https://www.ruby-lang.org/), ~~46~~ 60 bytes ``` a="";loop{q=$<.getc;~p if a[-5..-1]=="hello"\|\|!q;a+=q;$><<q} ``` [Try it online!](https://tio.run/nexus/ruby#HcsxDoMwDADAr5goW0Ukhk6J2XkD6mAlboNk4QTYoHw9lXr7NUJjvKiWs6IN7sNH9HeB5Q0090/n@uGFaDKLqLmurnp6YPV2DKF@W5tA18iQKQFB1m1niCTCCf6jLCu5Hw "Ruby – TIO Nexus") Reads characters from stdin until the last 5 are `hello`, then outputs the string (or until no characters are left in stdin). Terminates with error. Equivalent to: ``` a = "" loop { q = $<.getc ~p if a[-5..-1] == "hello" \|\| !q a += q $><< q } ``` Or, more ungolfed: ``` a = "" loop do q = STDIN.getc break if a[-5..-1] == "hello" or not q a += q print q end ``` [Answer] # Python 3, 120 116 104 Bytes Works with infinite streams, first time golfing, any tips are appreciated. ``` import sys a=1 c='' while(a): a=sys.stdin.read(1) if a:print(end=a) c=(c+a)[-5:] if c=='hello':break ``` Thanks @DJMcMayhem for saving some bytes :) [Answer] # Cubix, ~~94 83 82 79 63~~ 56 bytes ``` p>q'-?w.uh'e@U7.'hqi?oqB-!ul.-..$WWu_q<o'\;>....6t?.../!@ ``` Expanded: ``` p > q ' - ? w . u h ' e @ U 7 . ' h q i ? o q B - ! u l . - . . $ W W u _ q < o ' \ ; > . . . . 6 t ? . . . / ! @ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ``` # Notes * The interpreter disables the input field when the program starts. As such, an infinite stream of input is impossible. This program takes the input character-by-character, so if it weren't for this limitation, it would work properly. * This program doesn't clear up the stack, and it gets messy very quickly. Since the machine this will be used on apparently can give infinite input streams, it seems reasonable to assume that it also has infinite memory. * Any and all golfing help is much appreciated. # Try it online You can try the program [here](https://ethproductions.github.io/cubix/?code=cD5xJy0/dy51aCdlQFU3LidocWk/b3FCLSF1bC4tLi4kV1d1X3E8bydcOz4uLi4uNnQ/Li4uLyFA&input=SSBvbmNlIGhhZCBhIGhvcnNlIGNhbGxlZCBoZWxsb3BpbmEu&speed=1000). # Explanation ## General idea The general idea is that we want to read a character, and then check it against varying characters (first `h`, then `e`, then `l` etc.). To keep track of the character we have missed, we keep it at the very bottom of the stack. When we need it, we can easily bring it to the top again. ## Read/Write loop The read-write loop is simply the 5th line. All characters that are not used are replaced by no-ops (`.`): ``` . . . . . . . . . . . . @ . . . ' h q i ? o q B - ! u l . - . . . . . . _ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ``` This can be split up in two parts: Reading and (writing and checking). The first part contains the instructions up to and including the question mark. The second part up is the rest of the line. Because this loops around, we assume we start with a stack of `[...]` ``` @ 'hqi? _ Explanation 'h Push the character code of the h Stack: [..., 104] q Send it to the bottom Stack: [104, ...] i Read one character of the input (-1 for EOF) Stack: [104, ..., input] ? Start of condition: if (input < 0): @ execute '@', ending the program if (input = 0): continue going right if (input > 0): _ turn to the right, reflect back ('_') and turn right again, effectively not changing the direction at all ``` The second part (writing and checking) is linear again. The stack starts as `[next-char, ..., input]`. We abstracted the next character, because that changes later in the program. ``` oqB-!ul.- Explanation o Output the character at the top of the stack q Send the input to the bottom of the stack Stack: [input, next-char, ...] B Reverse the stack Stack: [..., next-char, input] - Push the difference of the top two characters, which is 0 if both are equal, something else otherwise Stack: [..., next-char, input, diff] ! if (diff = 0): u make a u-turn to the right else: l. execute two no-ops - push [input - next-char - input], which is disregarded later, so it effectively is a no-op as well. ``` Now, the IP will start again at the beginning of this loop, resetting the next character to check to `h`. # Matching the next character If the IP made a u-turn (i.e. the character we read and printed matched the next character in `'hello'`), we need to check what character the input was and depending on that, push the next character to the bottom of the stack. After that, we need to return to the read/write loop, without pushing `h` to the stack, so we need another way to get there. First things first: determine what character the input was. The stack looks like this: `[..., prev-char, input, 0]`. ``` . . . . - ? . . u h ' e . . . . . . . . . . . . . ! u . . . . . . . . . . . . . . \ ; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ``` To compare the input, we use the character code of `h` again. Initially, this was because I didn't really know how I was going to handle this and `h` is the first character in the string to check for, but it ended up being quite convenient. If we subtract the character code of h from the input, we get `-3` if the input is `e`, `0` if the input is `h`, `4` if the input is `l` and `7` if the input is `o`. This is useful, because the `?` command lets us easily separate negative values from positive values and zero. As such, if the IP turns left, the difference was negative, so the input was `e`, so the next character should be an `l`. If the IP continues going straight, the difference was `0`, so the input was `h`, so the next character should be an `e`. If the input is an `l` or an `o`, the IP turns right. All instructions executed before the aforementioned question mark are: ``` ;!e'h- Explanation ; Delete the top of the stack Stack: [..., prev-char, input] ! if (input = 0): e execute 'e' (no-op) 'h Push the character code of h Stack: [..., prev-char, input, 104] - Push the difference of the input and 104 Stack: [..., prev-char, input, 104, diff] ``` Now the IP changes its direction as detailed above. Let's go over the different possibilities. # Input `'e'` First we'll consider the input `e`, which causes the IP to move upwards from the `?`, since the difference is 3. All irrelevant characters have been removed from the cube. ``` . > q ' . ? . . . . . . . . . . . . q . . . . . . . . l . . . . $ W W . . . . . . . . > . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ``` The characters are executed in this order (excluding some control-flow characters): ``` q'l$WWq q Save the difference (-3) to the bottom of the stack so we can tell whether the l on the bottom of the stack is the first or the second l in hello Stack: [-3, ...] 'l Push the character code of l to the stack Stack: [-3, ..., 108] $W no-op W Sidestep into the loop q Send the character code to the bottom Stack: [108, -3, ...] ``` Now the IP has reached the read/write loop again. # Input `'h'` If the input was `'h'`, the difference is 0, so the IP doesn't change its direction. Here's the cube again, with all irrelevant characters removed. Since this path includes quite a few no-ops, all the no-ops it passes have been replaced by `&`. The IP starts at the question mark. ``` . . . . . ? w . . . ' e . . . . . . . . . . . . . ! . . . . . . . . . u _ q < . . \ . . . . . . . . ? & & & / . . & . . . . . . . . & . . . . . . & . . . . . . . . . . & & & & . . . . . . . . ``` The instructions executed are: ``` 'e!\?q_ 'e Push the character code of the e Stack: [..., 101] ! if (101 = 0): \ reflect away (effectively a no-op) ? if (101 > 0): turn right (always happens) q Move 101 to the bottom of the stack Stack: [101, ...] _ No-op ``` And now we're entering the read/write loop again, so we're done. # Other inputs All other inputs result in a positive difference, so the IP turns right at the question mark. We still need to separate the `l` and the `o`, so that's what we'll do next. ## Separating the `'l'` and `'o'` Keep in mind that the difference is 7 for `o` and 4 for `l` and that we have to end the program if the input was an `o`. Here's the cube again with the irrelevant parts replaced by a `.` and the no-ops the IP crosses have been replaced by ampersands. ``` . . q . . ? w . . h ' . . U 7 . . . . . . . . . . . . . . - . . . . . . . . . . . . . . . & . . . . . . . . / ! @ . . . . & . . . . . . . . & . . . . . . & . . . . & . . . & . . . & . . . & . h7'wq-!@ h no-op 7 Push 7 to the stack Stack: [..., diff, 7] 'wq Push w to the stack and send it to the bottom. We don't care about it, so it's now part of the ellipsis. Stack: [..., diff, 7] -! if (diff = 7): @ End the program ``` # Discerning between the two `'l'`s So, now we've we know that the input was an `l`, but we don't know which `l`. If it's the first, we need to push another `l` to the bottom of the stack, but if it's the second, we need to push an `o`. Remember we saved `-3` to the bottom of the stack just before we pushed the first `l`? We can use that to separate the two branches. ``` . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 t ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ``` The stack starts as `[..., -3 or 140, ...]` ``` Explanation 6t? 6t Take the 6th item from the top and move it to the top (which is either -3 or 140) ? If that's positive, turn right, otherwise, turn left ``` ## First `'l'` If this was the first `'l'`, we need to push another `'l'`. To save bytes, we use the same characters as for the first `'l'`. We can simplify the stack to `[...]`. Here's the relevant part of the cube, with no-ops replaced by ampersands. ``` p > q ' . . . . . . . . . . . . ' . q . . . . . . . . l . . . . $ W W . . . . . . . . > & & & & . . ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ``` The following instructions are executed: ``` $'pq'lq $' no-op pq no-op 'l Push the character code of l Stack: [..., 108] q Send it to the bottom Stack: [108, ...] ``` We're about to enter the read/write loop, so we're done with this branch. ## Second `'l'` If the input was the second `'l'` in `'hello'`, the IP turned right at the question mark. Once again, we can simplify the stack to `[...]` and the IP starts at `?`, pointing south this time. ``` . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . u _ q < o ' \ . . . . . . . . ? . . . . . . & . . . . . . . . & . . . . . . & . . . . . . . . . . & & & & . . . . . . . . ``` The instructions executed are: ``` 'oq_ 'o Push the character code of 'o' Stack: [..., 111] q Move the top item to the bottom Stack: [111, ...] _ No-op ``` And the IP is about to enter the read/write loop again, so we're done with this branch as well. [Answer] ## Haskell, ~~41~~ ~~47~~ 43 bytes ``` f l\|w@"hello"<-take 5l=w\|a:b<-l=a:f b\|1<2=l ``` Haskell's laziness handles the infinite input/output quit well. [Try it online!](https://tio.run/nexus/haskell#XY29CsIwEMdf5U9wKxUUXEoCrs4@wbW9mMPzUtpIl7x7LW66/z7EopgUvpdZ7IEAd0O2gZFoBCHleWEMpMojEqvmSYyODk0D@VG3CK3r1X0h59tCT8ZFw1qp632rgbqIvp78Oej2IrH9Nb3LLuOA@B/7AA "Haskell – TIO Nexus") Edit: didn't handle finite input - fixed. Thanks @Leo for pointing out. Edit II: @Ørjan Johansen saved 4 bytes. Thanks! [Answer] # C++, ~~142~~ 141 bytes ``` #import<iostream> void f(std::istream&i){i>>std::noskipws;char c;for(std::string s=" ";s!="hello"&&i>>c;)s.erase(0,1),s+=c,std::cout<<c;} ``` [Try it online!](https://tio.run/nexus/cpp-gcc#XY/BasMwDIbveQrNhRCzUNZrneTexzCyu4g6VrDc9lD67FkSMwbTSUj/9//ScqBp5pQ7YsnJ22moHkwOro1kdz5TGdakXzQM@yiy3Gh@isHRJkBz5VS0q5TiN0ivYCtl5KNXow@BVV2vNBotR5@s@OarPelWPntsdxL5nrsOzXs5UMRwd76T32soZpgsxUZXr2rz/Zd1AY7oYbQOLIycxAPaELyDPXqmaI/K/JFU0GIPIo3osl0/3tr38gM) [Answer] ## Node, 124 bytes ``` with(process)with(stdin)on('data',d=>[...d].map(c=>(s=(stdout.write(c),s+c).slice(-5))=='hello'&&exit()),setEncoding(),s='') ``` Not assuming that the stream will fit in available memory. [Answer] # C#, 134 bytes ``` using C=System.Console;class P{static void Main(){var s="";for(int c;(c=C.Read())>=0&!s.Contains("olleh");C.Write(s[0]))s=(char)c+s;}} ``` [Try It Online](https://tio.run/nexus/cs-core#FcyxbsMgEADQX6EeIlAlKztyF8@VqnboUGU4H2AuIRBz4IRE@Xa33Z/eVpniLMbhq3Gx535MkVOwGgMwi48HFyiEYk1kxDtQlOqxQhY8dJ12KUuKRaCWOIz9pwUjlXob9rsX/o/Kn2fZpRCs75Qe@@9MxUr@2R@U4kGih6zwlfXzuW3L1ebSKqVLOB397AzD/YbrFM9xWvF2BzZu9sdTuCSqrWR7XbwNIS3k52acn1IF02aHBIarm5AiGNdWBKrG/QI) Reads a character, checks it isn't -1 (EOS) and that we havn't seen "hello" yet, then prepends it to a string, and writes the character out. We prepend because `s[0]` is a lot shorter than `(char)s`. This has a quadratic cost in the length of the string, as it has to allocate and scan the entire input each time it reads a character (this will crash after 2GB of input due to constraints in the CLR, is that allowed?) ``` using C=System.Console; class P { static void Main() { var s=""; for(int c;(c=C.Read())>=0&!s.Contains("olleh");C.Write(s[0])) s=(char)c+s; } } ``` For a (longer: 142 bytes) version which won't run out of memory, and which has constant per-character cost, see below: ``` using C=System.Console;class P{static void Main(){var s=" ";for(int c;(c=C.Read())>=0&s!="hello";C.Write(s[4]))s=s.Substring(1)+(char)c;}} ``` This one keeps the last 5 characters in a 5-length string, which means short comparisons, and cheap last-char lookup, but is considerably more expensive to update. ``` using C=System.Console; class P { static void Main() { var s=" "; for(int c;(c=C.Read())>=0&s!="hello";C.Write(s[4])) s=s.Substring(1)+(char)c; } } ``` [Answer] # PHP, ~~57 55~~ 53 bytes ``` while(hello!=$s=substr($s.$c,-5))echo$c=fgetc(STDIN); ``` as there are no infinite files, I take input from STDIN. Run with `-nr`. Loop through input, print the current character, append it to `$s`, cut `$s` to the last 5 characters. Break loop when `$s` is `hello`. [Answer] # Vim, 39 bytes ``` :im hello hello:se noma :map : i i ``` [Try it online!](https://tio.run/nexus/v#Jcw9DoAgDEDhnQ1XloZFvUIv4DFMQ2to5C8yeXo0urzte7wN1AxRUqp/rcMuUGomazBTAwS1xuhwfmfGQCnBIcKn3H2ZdfLzOhRqCQKxXi/9Lk0LPQ "V – TIO Nexus") ``` :im hello "Remap 'hello' in insert mode to hello "write hello, then hit escape :se noma "then set the buffer to not-modifiable :map : i "THEN remap ':' to 'i' so that can't be changed i "enter insert mode and await an infinite stream of input ``` [Answer] # PowerShell, 111 bytes There is probably a better way to do this, but I can't see it at the moment. ``` while(($x=($x+$host.UI.RawUI.ReadKey("IncludeKeyDown").character+" ").substring(1,5)).CompareTo("hello")){} ``` This reads the key strokes without supressing the echo. The character is added to $x which is trimmed to the last 5 characters and compared to "hello". This carries on until the comparison is true. Note: this does not work in the PowerShell ISE. ReadKey is disabled in that environment. [Answer] # Scheme 115 bytes ``` (do((c(read-char)(read-char))(i 0(if(eqv? c(string-ref"hello"i))(+ i 1)0)))((or(eof-object? c)(= i 5)))(display c)) ``` Readable version: ``` (do ((c (read-char) (read-char)) ; read stdin (i 0 (if (eqv? c (string-ref "hello" i)) (+ i 1) 0))) ; check target ((or (eof-object? c) (= i 5))) ; finish if end of stdin, or word found (display c)) ; display each character ``` This takes an individual char from stdin each time around the loop, and marks off its position on the target word as it meets the characters of "hello". Stops when the input runs out or "hello" has been seen. No memory used on infinite stream. [Answer] # AWK, 95 bytes ``` BEGIN{RS="(.)" split("hello",h,"")}{for(j=0;++j<6;){c=RT printf c if(c!=h[j])next getline}exit} ``` There are 2 things I learned here: 1) To split records between characters use `RS="(.)"` and then `RT` must be used instead of `$1` 2) `ORS` is used by `print` and is defaulted to `"\n"` 3) I can't count to 2 and using `printf` is "cheaper" than assigning `ORS` and using `print` Example usage: Place code in FILE ``` awk -f FILE some_data_file ``` or ``` some process \| awk -f FILE ``` Code was tested using Dennis's `yes \| ...` suggestion and I saw lots and lots of `y`s. FYI, you can do the RS assignment as an option and pull it out of the `BEGIN` block via: ``` awk -v RS='(.)' ``` [Answer] # [Python 3](https://docs.python.org/3/) (Linux), ~~73~~ 72 bytes ``` s=c='_';I=open(0) while'olleh'!=s>''<c:c=I.read(1);s=c+s[print(end=c):4] ``` Thanks to @MitchSchwartz for golfing off 1 byte! [Try it online!](https://tio.run/nexus/python3#DcxBCgMhDADAe1@RnqIUli30tNv07htKKSEGFMSILvT5dh8wMwcJ4Rf3QNa0utVffikXRStFE15pvBCfsgmFpStHd/f7SW7j3Xquh9MaSfz2@MwZwKooJI7AkKwPBeFziZC0FGu58vIH "Python 3 – TIO Nexus") [Answer] # Ruby, ~~59~~ ~~49~~ ~~48~~ 43 bytes Now rant-free, shorter, and without memory leak. ``` s='' s=$>.putc$<.getc+s[0,4]until'olleh'==s ``` Saved 5 bytes by getting rid of some parentheses and a space thanks to Dennis [Answer] # 8086 machine code, 22 bytes ``` 00000000 bf 11 01 b4 01 cd 21 ae 75 f6 81 ff 16 01 72 f3 \|......!.u.....r.\| 00000010 c3 68 65 6c 6c 6f \|.hello\| 00000016 ``` Equivalent assembly code: ``` org 0x100 use16 a: mov di, msg b: mov ah, 1 ; read one byte from stdin with echo int 0x21 ; dos syscall -> result in AL scasb ; if (DI++ == AL) jne a cmp di, msg+5 jb b ret msg db "hello" ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 24 bytes ``` “Ṣẉ»ẇ⁸Ṇȧ® ṫ-3;ƈ©Ȯ¤µ⁺Ç¿ṛ“ ``` [Try it online!](https://tio.run/nexus/jelly#AV0Aov//4oCc4bmi4bqJwrvhuofigbjhuYbIp8KuCuG5qy0zO8aIwqnIrsKkwrXigbrDh8K/4bmb4oCc//9JIG9uY2UgaGFkIGEgaG9yc2UgY2FsbGVkIGhlbGxvcGluYS4 "Jelly – TIO Nexus") Explanation: ``` ṫ-3;ƈ©Ȯ¤µ⁺Ç¿ṛ“ Main link. Arguments: 0 ṫ-3 Truncate the list to its 4 last elements. ;ƈ©Ȯ¤ Store a character from STDIN in the register, print it, and append it to the list (list is initially [0]). µ Start a new monadic chain, everything to the left is a link. Ç Execute the helper link with the existing list as its argument. ⁺ ¿ Do-while loop, left link is body, right link is condition. ṛ“ When the loop ends, replace the return value with [] (invisible on output). “Ṣẉ»ẇ⁸Ṇȧ® Helper link. Arguments: string “Ṣẉ»ẉ⁸Ṇ Check if "hello" isn't in the string. ® Return the character we stored in the register. ȧ Check if both of the above are truthy. ``` [Answer] # Pyth, ~~49~~ 47 bytes ``` Wn"hello"=>5+kp$__import__("sys").stdin.read(1) ``` Pyth's not very good at taking a single character of input. Everything in `$__import__("sys").stdin.read(1)` is simply doing that. Also, it means that this only runs offline. Everything else is short... The program is a bodyless while loop. Inside the condition, the program reads a character, prints it back, appends that character to `k` (which is initially the empty string), trims off all but the last 5 characters of `k`, and then checks that the result is not `"hello"`. 32 characters are getting one byte of input, 15 characters does the rest. Tested on Linux, works even with no newline, infinite input, etc. [Answer] # Lua, ~~68~~ 64 bytes ``` l=""while l~="hello"do c=io.read(1)io.write(c)l=l:sub(-4)..c end ``` [Answer] # [Röda](https://github.com/fergusq/roda), ~~49~~ 47 bytes ``` {a=[0]5{\|x\|[x];a=a[1:]+x;z if[a&""="hello"]}_} ``` [Try it online!](https://tio.run/nexus/roda#HcxLCsIwFEbhcbqKnzsQH@Bj4MSSBbiGGOTSJDQQkxIrFNOsvUpnh29wXuwjCpx8LIWlOuv9tczTrCbdsmR1uenD1H7hneINkaTehpBI12ddhEsZPg6fESY1QmzXPhHtMMP9Ycg@jiBqhEnRNnW5I8XOomcDRp/y26LjEKzBuh185OMP "Röda – TIO Nexus") This is an anonymous function that reads characters from its input stream and outputs them until "hello" is found. It uses the array `a` to track the last characters. It outputs some junk to STDERR, but I understood that is [allowed](https://codegolf.meta.stackexchange.com/a/4781/66323). Explanation: ``` { a=[0]5 /* Initialize the array with 5 zeroes. / {\|x\| / For each x in the input stream: / [x]; / Print x / a=a[1:]+x; / Add x and remove the sixth last character. / z if[a&""="hello"] / If "hello" is found, crash the program / / with an undefined variable. / }_ / End for loop. / } ``` [Answer] # Java 7, ~~122~~ ~~118~~ ~~124~~ ~~123~~ ~~150~~ 141 bytes ``` void c()throws Exception{String a="aaaaa";for(int b;!a.equals("hello")&(b=System.in.read())>=0;a=a.substring(1)+(char)b)System.out.write(b);} ``` Now stops when the end of the stream is reached. Now handles infinite input without running out of memory. [Answer] # Ruby, 51 bytes ``` x="";$><<x[-1]while/hello./!~x=x[/.{0,5}$/]+$<.getc ``` Does not expect newlines * Works with infinite input [Answer] # [AHK](https://autohotkey.com/), 116 bytes ``` Loop,Read,%1% {a=%A_LoopReadLine%`n Loop,Parse,a {Send % c:=A_LoopField If((f:=c SubStr(f,1,4))=="olleh") ExitApp }} ``` There's nothing clever or magical in there, really. The variable `%1%` is the first passed argument and should be a file path with the stream. The file must be saved as it is updated but the code will read to the end even if it expands after the reading starts. [Answer] # Mathematica, 107 bytes ``` i="";EventHandler[Dynamic@i,"KeyDown":>(i=i<>CurrentValue@"EventKey";If[StringTake[i,-5]=="hello",Exit[]])] ``` The output becomes a field where the user can infinitely type text (including newlines) until the last 5 characters are equal to `"hello"`; at that point, it exits. [Answer] # [brainfuck](https://github.com/TryItOnline/tio-transpilers), 281 bytes ``` >++++++++[<+++++++++++++>-]>++++++++++[<++++++++++>-]<+>>+++++++++[<++++++++++++>-]>++++++++++[<+++++++++++>-]<+>+[[[[[,.<<<<[->>>>->+<<<<<]>>>>>[-<<<<<+>>>>>]<],.<<<[->>>->+<<<<]>>>>[-<<<<+>>>>]<],.<<[->>->+<<<]>>>[-<<<+>>>]<],.<<[->>->+<<<]>>>[-<<<+>>>]<],.<[->->+<<]>>[-<<+>>]<] ``` I'm not sure why, but I just felt like brainfuck was the right thing to do this. Doesn't require infinite memory, and can output forever. ## Explained ``` Set up the buffers with helo This is done Naively; sue me >++++++++[<+++++++++++++>-] h >++++++++++[<++++++++++>-]<+> e >+++++++++[<++++++++++++>-] l >++++++++++[<+++++++++++>-]<+> o THE MAIN LOOP + [ matches o [ matches l [ matches l [ matches e [ matches h ,. Read a character and immediently write it <<<<[->>>>->+<<<<<] Subtract it from h >>>>>[-<<<<<+>>>>>] Correct the h < Terminate this part of the loop if it matches h ] ,. Same as above <<<[->>>->+<<<<] Subtract it from e >>>>[-<<<<+>>>>] Correct the e < Terminate this part of the loop if it matches e ] ,. Same as above <<[->>->+<<<] Subtract it from l >>>[-<<<+>>>] Correct the l < Terminate this part of the loop if it matches l ] ,. Same as above <<[->>->+<<<] Subtract it from l >>>[-<<<+>>>] Correct the l < Terminate this part of the loop if it matches l ] ,. Same as above <[->->+<<] Subtract it from o >>[-<<+>>] Correct the o < Terminate this part of the loop if it matches o ] ``` [Try it online!](https://tio.run/nexus/brainfuck#jYtBCoQwDEWvEtffeoKQi5QsBAUXlcLgMHj62saKXSjM3728lySo84x24lRuamU2DBE8P77/1Uf4sn7gPO8kzwkKsBYQ7wxgoKxWWlg7vSs0TUnOQi@PP22W5vQ0sHtKe/zSMk60zjRutMwhRPrFT5i6Aw "brainfuck – TIO Nexus") ]
[Question] [ ## Introduction: Although we have a lot of challenges where swapping two items in a list is a subtask, like [Single swaps of an array](https://codegolf.stackexchange.com/q/152283/52210); [Swap to Sort an Array](https://codegolf.stackexchange.com/q/197536/52210); [\$n\$ swaps into a nop](https://codegolf.stackexchange.com/q/235710/52210); etc., we don't have the simple challenge of just swapping two items given a list and two indices. Input: A list with some positive integers \$L\$, and two indices \$a\$ and \$b\$. Output: The same list, with the two items at the given indices swapped. ## Challenge rules: * The input-list is guaranteed to contain at least two items. * The input-list is guaranteed to only contain positive integers. * The input-indices can be either 0-based or 1-based (please specify in your answer which of the two you've used). * The input-indices are guaranteed to be valid indices based on the length of the input-list. * The input-indices are distinct, so will never be the same index. (The values in the input-list won't necessarily be distinct.) * You can assume \$a<b\$ (and you're allowed to take the inputs in reversed order if it helps). * I/O is flexible. You're allowed to take the input as a list/array/stream, from STDIN, as a delimited string, etc. You're allowed to modify the input-list directly, or return a new one with the two items swapped. ## General rules: * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the 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 with [default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/), 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 (e.g. [TIO](https://tio.run/#)). * Also, adding an explanation for your answer is highly recommended. ## Test cases All test cases use 0-based indices. ``` Inputs: L=[1,2,3,4,5,6,7,8,9,10], a=3, b=7 Output: [1,2,3,8,5,6,7,4,9,10] Inputs: L=[ 3, 8, 1, 4,10,10,10,10], a=0, b=5 Output: [10, 8, 1, 4,10, 3,10,10] Inputs: L=[5,1,4,2,3], a=0, b=4 Output: [3,1,4,2,5] Inputs: L=[5,6], a=0, b=1 Output: [6,5] Inputs: L=[2,2,2], a=0, b=1 Output: [2,2,2] ``` [Answer] # Java, 27 bytes ``` java.util.Collections::swap ``` [Try it online!](https://tio.run/##ZU/BTsMwDL33K3xMJRMxBgzWDQkhTUKC046IQ@iSKl2aVrE7NE399pKugyF4F8vPfs/Ppdqpi3Kz7W3V1IGhjL1s2Tr5Yomz5B/9GILaU5Y07YezOeROEcGrsh4OCURYzzoYlWtYHXa13YARg9PiOfKFDg/gYofDGtixlGnWHaUnS2LFsRzFVTQWaw7WF2/voEJB6XhmwArMsj8ne6qd0znb2tN8Tp@q6b8Xsx/JnyiwhPEfqWgYiQle4RSv8QZvcYZ3eI@Ty/QsN9IIhzBFmP1i13tiXcm6ZdnEpOy8cKdxl3T9Fw) [Answer] # [Python 2](https://docs.python.org/2/), 32 bytes ``` def f(a,b,l):l[a],l[b]=l[b],l[a] ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m728oLIkIz_PaMGCpaUlaboWNxVSUtMU0jQSdZJ0cjStcqITY3VyopNibUGEDogLVaeWY5uZV1BaoqHJlaYBZenA6BxNroKizLwShRyI6gU7o411LHQMdUx0DA3gKJbLgMsUogAA) Mutates the input in-place. --- 26 bytes with a [NumPy](https://numpy.org) array: ``` def f(l,a):l[a[::-1]]=l[a] ``` [Try it online!](https://tio.run/##PYtLCgMhEAX3fQqXCh0YJwkEYU4ivRAmEsFP0zgLT28@DIGCqrd4PPqr1XXO/RlV1BmDcdkH79zFEm2fpBmlFVWPwkOlwk26CiJhQN5@1qny0bUx8P37c@FpMsCSald5@is@0OIN7fKHYIE7vAE "Python 2 – Try It Online") [Answer] # [Brain-Flak](https://github.com/Flakheads/BrainHack), 122 bytes ``` (([{}]{()<({}[()]<({}<>)<>>)>}{})<(({}({}))([{}]{})<{({}()<<>({}<>)>)}{}>)>())<>({}<<>{({}[()]<({}<>)<>>)}{}>){<>({}<>)}{} ``` [Try it online!](https://tio.run/##ZYw7CoBADAWvk1f6K4SQiyxbqI0iWNiGPfsz62IlBIYMk6z3clz7sp2kSPKSXaDiJQlypRrUDFa8hA8RA7QyjFcDVWupIbqAAE2p@f/Z2/h3ExvJniNndsGBE6cH "Brain-Flak (BrainHack) – Try It Online") # Works with all integers, 138 bytes ``` (([{}]{()<({}[()]<({}<>)<>>)>}{})<(({}({}))([{}]{})<{({}()<<>({}<>)>)}{}>)>())<>({}<<>{({}[()]<({}<>)<>>)}{}>)<>([]){({}[()]<({}<>)<>>)}<> ``` [Try it online!](https://tio.run/##bYw7CoBADESvkyn9FULIRZYt1EYRLGzDnj3OuqVCYIY3j6z3clz7sp0RIslLdoGKlyTINdWgZrDihZyABzSTxCuBqjXVQI8hQENq/n32OtxTxt@qFhF9jDFHxxzYpgc "Brain-Flak (BrainHack) – Try It Online") The difference here is that while the first uses ``` {<>({}<>)}{} ``` To pull all the items from the off stack onto the on stack this one has to use ``` <>({}){({}[()]<({}<>)<>>)}<> ``` The first one pulls until it hits a zero and then stops, so this will fail to produce the correct result when there is a zero before the first swapped value. The second checks the height and pulls that many times, thus it will work for any list. [Answer] # [R](https://www.r-project.org/), 31 bytes Or [R](https://www.r-project.org/)>=4.1, 24 bytes by replacing the word `function` with `\`. ``` function(L,A){L[A]=L[rev(A)];L} ``` [Try it online!](https://tio.run/##fYuxCsIwFEX3fsUDlxd8Q5M0VSoZsgf8gJBBgwGXKiVxEb891lJLQRDucOGcM5SoS8x9SNdbj5YMe1pnvLZuuDzQMH@wrxKRd7ymgJJ2bMtZFfHzYU/ACRoa2XeMIOBJ1wRnrRZXEaeGBMk1bia8OeZ0z6kDACdnTflqztp1wH@CdlHFmIn/8qT48gY "R – Try It Online") Takes input as a vector and a vector of two `1`-based indices. [Answer] # [Rust](https://www.rust-lang.org/), 11 bytes ``` <[_]>::swap ``` Modify the input in-place. [Try it online!](https://tio.run/##HcpLCoMwAEXReVbxdFAivEHtzzax7UJEihQDQgyisQ7EtaeS6bl3nCcfjEPfdE5mq7Cth8EToaw@9UupaWmGoCP3s4fd06/9JlVOnIgzcSGuxI0oiDvxIPJjrYWRh/jHp8i0GMbOeesSma7qvaWE3XELfw "Rust – Try It Online") [Answer] # [Factor](https://factorcode.org/), 21 bytes ``` [ [ exchange ] keep ] ``` [Try it online!](https://tio.run/##Dcw9DoIwAIbhnVO8JzAiKqgHMC4uxokwNM3nT2xKLSXBGM9eGZ/luRmb@pivl9P5uGfQe5S3GngpejlCVEqfEJ8@cSiKipovJSsq1mzYzm7YUS755ZYWTfZh/F1086BAl61xjkX@Aw "Factor – Try It Online") It's almost a built-in, but `exchange` has stack effect `( m n seq -- )` so we need `keep` to actually keep the sequence around on the data stack. 0-indexed. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 5 bytes ``` œPżịF ``` [Try it online!](https://tio.run/##y0rNyan8///o5ICjex7u7nb7H/qoYcbh5UpHJz3cOeNR05rI//@jjXUUzGN1FKINdBRMobQJlDaE0/@jDXWMdIx1THRMdcx0zHUsdCx1DA1A0gpA/RZAJUBdQBE4AkmZ6hgCNQC1QThmIMoIyDeKBQA "Jelly – Try It Online") Takes indexes as 1 indexed and reversed (so `[b, a]`), the Footer on TIO does this for you. ## How it works ``` œPżịF - Main link. Takes indices I on the left, array A on the right œP - Partition A at the indices in I, not keeping the borders ị - Retrieve the elements of A at the indices in I; [A[b], A[a]] ż - Zip together F - Flatten ``` [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 5 [bytes](https://github.com/abrudz/SBCS) 1-indexed. Reverse the sublist at the indices given by the second input of the first input. ``` ⌽@⎕⊢⎕ ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97f@jnr0Oj/qmPupaBCRBQv/TuB71blYwNOAyUbDgSuMyVrBQMFQwAQrAEZehghkA "APL (Dyalog Unicode) – Try It Online") [Answer] # Lean, ~~211~~ 205 bytes Helper: ``` notation `L`:=list ℕ structure R:=m::(A:L)(B:ℕ)(C:L) def r:L->L->ℕ->R \|p(h::t)0:=R.m p h t \|p(h::t)(n+1):=r(p++[h])t n \|_[]_:=R.m[]0[] ``` Actual function: ``` λl a b,let f:=r[]l a,z:=r[]f.C(b-a-1)in f.A++z.B::z.A++f.B::z.C ``` [Try it online!](https://leanprover-community.github.io/lean-web-editor/#code=import%20data.list.basic%0Aimport%20data.nat.basic%0A%0Anotation%20%60L%60%3A%3Dlist%20%E2%84%95%0Astructure%20R%3A%3Dm%3A%3A%28A%3AL%29%28B%3A%E2%84%95%29%28C%3AL%29%0Adef%20r%3AL-%3EL-%3E%E2%84%95-%3ER%0A%7Cp%28h%3A%3At%290%3A%3DR.m%20p%20h%20t%0A%7Cp%28h%3A%3At%29%28n%2B1%29%3A%3Dr%28p%2B%2B%5Bh%5D%29t%20n%0A%7C_%5B%5D_%3A%3DR.m%5B%5D0%5B%5D%0Adef%20s%20%3A%20list%20%E2%84%95%20-%3E%20%E2%84%95%20-%3E%20%E2%84%95%20-%3E%20list%20%E2%84%95%20%3A%3D%0A%CE%BBl%20a%20b%2Clet%20f%3A%3Dr%5B%5Dl%20a%2Cz%3A%3Dr%5B%5Df.C%28b-a-1%29in%20f.A%2B%2Bz.B%3A%3Az.A%2B%2Bf.B%3A%3Az.C%0A%0A%23eval%20s%20%5B1%2C2%2C3%2C4%2C5%2C6%2C7%2C8%2C9%2C10%5D%203%207%0A--%5B1%2C2%2C3%2C8%2C5%2C6%2C7%2C4%2C9%2C10%5D%0A%0A%23eval%20s%20%5B%203%2C%208%2C%201%2C%204%2C10%2C10%2C10%2C10%5D%200%205%0A--%5B10%2C%208%2C%201%2C%204%2C10%2C%203%2C10%2C10%5D%0A%0A%23eval%20s%20%5B5%2C1%2C4%2C2%2C3%5D%200%204%0A--%5B3%2C1%2C4%2C2%2C5%5D%0A%0A%23eval%20s%20%5B5%2C6%5D%200%201%0A--%5B6%2C5%5D%0A%0A%23eval%20s%20%5B2%2C2%2C2%5D%200%201%0A--%5B2%2C2%2C2%5D) There's got to be a way to make product types and define type aliases easily, but I couldn't find it. [Answer] # [Jelly](https://github.com/DennisMitchell/jellylanguage), 7 bytes ``` ,U$yJ}ị ``` [Try It Online!](https://jht.hyper-neutrino.xyz/tio#WyIiLCIsVSR5Sn3hu4siLCIiLCIiLFsiMSwgNiIsIlsgMywgOCwgMSwgNCwxMCwxMCwxMCwxMF0iXV0=) A totally different Jelly 7-byter, so I figured I'd post this too. This is 1-indexed. ``` ,U$yJ}ị Main link; take indices on the left ,U$ Pair the indices with the reverse of itself ([[a, b], [b, a]]) y Apply this as a translation to J} The indices of the right list (J takes a list of length L and returns [1, 2, ..., L]) ị Index back into the original list ``` [Answer] # [Haskell](https://www.haskell.org/), 56 bytes ``` (?)=splitAt (x!y)z\|(q,d:e)<-y?z,(a,b:c)<-x?q=a++d:c++b:e ``` [Try it online!](https://tio.run/##y0gszk7Nyfn/X8Ne07a4ICezxLGES6NCsVKzqkajUCfFKlXTRrfSvkpHI1EnySoZyKmwL7RN1NZOsUrW1k6ySv2fm5iZZ5uSz6VQUJSZV6JiqGikEm2oY6RjrGMSCxM0UDQGCurpGRrE/gcA "Haskell – Try It Online") `splitAt` breaks the list into two parts at the particular index. This is useful because unlike `(!!)` we can get all the parts first. To start we split at the second element, then the first. Splitting at the second first means we don't have to do extra arithmetic do calculate the offset which is required if we split at the first. We use a pattern match to then get the first element of various pieces. [Answer] # [Julia 1.0](http://julialang.org/), 20 bytes ``` Li=L[i]=L[i[[2,1]]] ``` [Try it online!](https://tio.run/##jY5NbsMgEIX3nGKWkI4i4784C25AT4BYEGWkUiHLcpw2t3fHxknkXRFC8973HvB9TzHoxzzbQzTWRb8czpWovffz71dMBNN4JwG8LAa8gAH6CUl@0hSOQxhvJEcK1xR7kkqpNUiP4T@xt7HK8GH0OlyewzDGfkq9lOvLW8seHAu/C1i1l2DM8gklqL/OTmOJFdbYYIsn7PCMuvAIFcJJbLDbYJ2hEG7BHYJGqNl5be4VCA33ih3neOZcbVDzRXxtDtfCVZvTZNxmoIVrs1UyK19mVn8 "Julia 1.0 – Try It Online") 1-indexed expects `L[a,b]` and mutates `L` [Answer] # JavaScript, 31 bytes ``` l=>a=>b=>l[a]^=l[b]^(l[b]=l[a]) ``` Only works for integers. [Try it online!](https://tio.run/##FYlNCoAgFAb3nUThC/rXFs@LiMIzEAqJKPH6VpuBmTm48LPd@5XbomukmsgwmUAmWXaekg3Oi5/0B/l922PAiAkzFihorOg7B6YRgVQTRZKCpQiyue79zJ/WFw) Thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563). # JavaScript, 32 bytes ``` l=>a=>b=>[l[a],l[b]]=[l[b],l[a]] ``` [Try it online!](https://tio.run/##FYpLCoAwEMX2nqSFJ/j/LKYXGWYxFQSlSKnS61ddhYScmvXe0hGfOi9lpxLIKTlPjgOrILAXIf6BP8g3cIsOPQaMmDBjwYq2ESj18DRXuwnWqDXeVjEd1/NpeQE) [Answer] # [stacked](https://github.com/ConorOBrien-Foxx/stacked), 5 bytes ``` $exch ``` [Try it online!](https://tio.run/##Ky5JTM5OTfn/XyW1Ijnjv4NVGheXhoaGoYKRgrGCiYKpgpmCuYKFgqWCoYGmAlDIXJNLQUPDGChkCJQ2NIAjoKyCgYIpWNoULAk0ASSIAAYKJlBpM1QJmLQhWNoIqNNIE6u0JhdXtJ6eXlqsQm5igUJ@acl/AA "Stacked – Try It Online") You can remove the `$` if input is allowed to be taken from the stack for 4 bytes. Convenient builtin to be sure. ## [22 bytes](https://tio.run/##bczLCsIwEIXhfZ7iLJNNyKRNq67yHiGLoBZab4FWxKePY/CC4DCr/2NmXtL2sN@VEvzkxzBiwnm@pRxTzsd7LH4zCCGlJFg0aOHQoccKa5BR4NQrASkbTsRM5rOsMHCVXUX@8IzfMWhf3P3Cm6my5Uur/rISImith4hTyrhcl/IA "Stacked – Try It Online") ``` [@j@i[i j nswap]apply] ``` Function. `nswap` performs a stack operation of swapping the `i`th and `j`th members, so we simply pop `i` and `j` and treat the stack at the top of the stack as the stack for `nswap`. [Answer] # Kotlin, 34 bytes ``` {l,x,y->l[x]=l[y].also{l[y]=l[x]}} ``` Ungolfed: ``` { l, x, y -> l[x] = l[y].also { l[y] = l[x] } } ``` This answer is a bit of an idiom in Kotlin. `Any#also()` basically executes the given function, but then returns the receiver. In this case, the outer `l[y]` is evaluated, then `.also()` runs the lambda `{ l[y] = l[x] }`, and returns the old value of `l[y]`. [Try it online!](https://tio.run/##RU7BCsIwFLvvK96xhbfhnDoVu7ugePI0dqhgoeytFdfJRtm3120ezCEkIZDU1pE24SMJ1BHYtXPyQc@Lbt3pbFyBMPFCHOIC7kY7EMET9jjEBZV9JagcqkRSa/2sxJyNY1CdgUZqwzh4iGDCPEEgoPlP3BRLcY0ZbnCLO8xxjwdMV3zpK0YIGUL@s/VyNNE2eb21cYx4NIYv) [Answer] # [CJam](https://sourceforge.net/p/cjam), 4 bytes ``` {e\} ``` Code block ([analogous to a function](https://codegolf.meta.stackexchange.com/a/2422/36398)) that pops three elements from the stack: `L`, `a`, `b`, and pushes the swapped version of `L`. Indices `a`, `b` are 0-based. [Try it online!](https://tio.run/##S85KzP1fWPe/OjWm9n9dwf9oBWMFCwVDBRMFQwM4ilUwUDAFAA "CJam – Try It Online") ### Explanation ``` { } e# Define code block e\ e# Swap elements in array ``` Header: ``` q e# Read all input as an unevaluated string, and push it to the stack ~ e# Evaluate string. Gives an array and two numbers, that are pushed ``` Footer: ``` ~ e# Execute block p e# Print string representation of the top of the stack ``` [Answer] # [Zsh](https://www.zsh.org), 39 bytes ``` eval "t=$`<i`;`<i`=$`<j`;`<j`=$"t <<<$@ ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwZqM1MQUBV1Du0wuu6ylpSVpuhY31VPLEnMUlEpsVRJsMhOsQQSImQViZgGZSiVcNjY2Kg4Q5Qsg1MZoQx0jHWMdEx1THTMdcx2L2CXGXGZcEEkA) Takes the array on the command line, with the two indices in files called `i` and `j`. A bit of quote trickery to avoid escapes. [Answer] # [C (clang)](http://clang.llvm.org/), 34 bytes ``` f(a,i,j){a[i]^=a[j]^(a[j]=a[i]);} ``` [Try it online!](https://tio.run/##rVPbbqMwFHzvVxwhpQLqaBNo2qQ0uw@r/QpCK0RMy6UkAqSNiPj1ZY8vgONQqQ9FwjaeOZcZm2ge5WHx1nWxaYckIal1Dv0keNmGfhq8mGzcsg3La7ukqOEjTArTgvMN4MM2alrVr0s/gC2c1wQ2BB4I3BN4JLBcEFjx1br1RrIjyILjDhQe5eCoct2Bu@Sgy8cN5z7wNaa@6CUXEVXS0ENsiu6sH/LTlt8EVNzRcEfDXQ13rbGmzYtWoqjITqRMObtag6@JIC@EJh1NBbri4lYKSk9HGtV035vN3FXdXutmDwGj4S4nfGL4wL8wfdOb7kybbg9xImpskygdKGt3QtPloY0pRuOVPaLTnAmacoZj5QnecJbRe1jaONIoo6Vox9id/ji70@Y3viuDgPrtGjIuPpRgMi1JsacnDFt4cvmsN3Bd3vLg7o6z@1@qdybHTOI6czjwVBQvnYSrKRgSieJVm4LTHk6v4GOJhNg0fMPSKjYY9BHm@SEy7@1cQQcDMiE@Q@E505WpmtjT@BnztcbJuwD6qrNqtkefs1/M7CcDRxai1GqvGg0IzPbshflP8DEiIZCq3ZnN1R5r9hhWFfay1FRS3Bvus27O15XK7Hy6vZXCMfO3KodZtSuQ2d9ZVk0NiUtKzUZutDdt9y@K8/Ct6uZ//wM "C (clang) – Try It Online") Port of [Unmitigated](https://codegolf.stackexchange.com/users/99986/unmitigated)'s [C++ answer](https://codegolf.stackexchange.com/a/236318/9481)* [Answer] # TI-Basic, ~~39~~ 33 bytes ``` Prompt L,A,B ʟL(A→X ʟL(B→ʟL(A X→ʟL(B ʟL ``` -6 bytes thanks to [MarcMush](https://codegolf.stackexchange.com/users/98541/marcmush). Input indices are 1-based. Output is stored in `Ans` and is displayed. [Answer] # [ErrLess](https://sr.ht/%7Eruan_p/Errless/), 6 bytes ``` 0m:r.M ``` A [macro](https://man.sr.ht/%7Eruan_p/errless_docs/reference.md#-procedures-amp-macros). ## Explanation ``` 0 { Push a 0 to the stack to identify the macro } m { Start macro definition } : { (L a b) -> (L (a b)) } r { Rotate } . { Halt (Return) } M { End macro definition } ``` You can test it with the following program: ``` 0m :r. M { Test cases: } 1,2x3x4x5x6x7x8x9xax 3 7 0" # a? { Outputs "(1 2 3 8 5 6 7 4 9 10)" and a newline } 3,8x1x4xaxaxaxax 0 5 0" # a? { Outputs "(10 8 1 4 10 3 10 10)" and a newline } 5,1x4x2x3x 0 4 0" # a? { Outputs "(3 1 4 2 5)" and a newline } 5,6x 0 1 0" # a? { Outputs "(6 5)" and a newline } 2,2x2x 0 1 0" # a? { Outputs "(2 2 2)" and a newline } . ``` [Try it online!](https://tio.run/##1VvpdtvGFf7Pp5jItQlIJEVK3kKbTh1v1Yltubba04ZieIbAkIQNAshgaJFynJ99gD5iX8S9dxZgsJCSHatJ5WNKGMzc@9117ixM1mIeR4d3E/7pGnnKhDdnPpnyeEHmQiRpf39/FohOyjtzsf8rX9JonOwzzkOWpmPOpum@4IztL2gQ7QeCLfYnwSyIxHgZBV7ss/1EkTdDOsmaUEEOu@TYE/GEcXLQPeg1gkUSc0EonyWUp8w8p@vU/CmCBWs0vJCmKQmipN8g8OOzKRmPgygQ47GTsnDqqnb8wceOTwUlA9JsNrL@MybCIGLl7pyJJY@sUXvIvZMKP4g6nFFfDnKH/XZvVCAmCbVIGpyzQbtnUQymspHcJ93@xeQdN4cCiLOOwz4SGd0ryJO/xZf9UVkKXiWPHdshixzuugX8QVkTEZsBi6c0BDtUIKHAvRzq2TwIGeGdIE0T6oF@cjLbhoFq4BXYpd3sa34nfMnuXcAnigXhQzBAzo/QyM/afHA9UcWwV0/TVqikgEozbQXJubK6aRJ8XWKhtA5uD9pF4RAoisVAh6St2rMRbOWxRJC/03DJnnAe81piQ/Ay8HPgDp/gHA00V5jEiRO2SJB7GnAL0iBKBY1AH/AuDFLhnhqSqB7HCciDAenKhwD8Ed0gdF0Sc@Lgs3rjtAOX3B@Yt9XYCDvIPlCSWDAVMsbe/Y7QhsGoFlYKNkdULbL6H6JCOGC5lQVJ4ZmGVAjZPQODvlIDKEsZw1BLBgSH6s8p4GDgFyS0FNFhK6DsO4YFcwuG4gqAFydrm3sd57Jyh3IQcy2@BWWHirQfj5eOSSRS2LGzqlKbQmON3CvNXcXMEMauFcM1MlwVGE7HGUe/wrFF1hZT2iITjKEqo5bduNaNdoai0siT@ugETuctcqYg4l@I8jxIFP88V7AQKW2jocU8t8TMBm5mDmzOrYHrUY2akXZZbWoCfclA7knI@sadzij3QU0fMirNc8jMzR@brbzlA7Z8tFscbHHtlgW2vNAtH@XnhHrvquTX2PGf9tCP2PLBbnGxxbFbXmDLIiMvnSB9FyRjL14sGKTZhMezFkkEbxmp0gHOLMbhIw9g9NC65rXO0T353ptTDDOkMgQiSqkRKEumYU8@poIHEc5Y2FnNpHp2gn65vWA4TjxmlGm6rtIFcsidrZatxWtPM7OcUw0ZSKsUfESihQG9oidl/T/W9W9jf9tVHICxB9jd6xnalkZjaV3r0NY6koNOA1k@tAgkpMHLODL636jfMfij9w4zHHYZ1Shay80wI4MDA82@fBhkztzRcDSJkmUUh4p9eldiHUerAScMo/kcxLA7UnWLfAXRW5agaKFt1tbAW2SMhVNtJLiVATnuceWdF0cAfMkqPqKgd2iS4CSDgNyihzmoubynS76xtZtPrmVhZVlmKQcqrZa0r4sSS0b9TWiwHinBKKMYYLxnyoYngH8BvUog9LaHgclwf5Q4MHguHwjtP1ogGBE2R8LHz4@EllrU/GEDwgj9fx0RYpkA08@uMXEYc8zglSptVrLWVOJIUYqU5JiatUBNbcpjQYUcFCcXl971FKsD4sQUrQAW9QHEcUHQ20BBLHA9ly2V4gQDIKvoA5SW02jGnF7LkLPAQD2nCMBnq0AlGOUmNyse2YyrnkaptTuSdNwaLc04nTgp0LbUZNrHTtYkQ8Y4vlmSIlY1AJcBcoSLQ7T@l8pZ@ugrMhj7uFxG18FkJLUIJdsySvvEDzzQaPsBdtAF6jIq5B3ZeO0aeXPy8NEP5PjVk9cPT46OX75pGDvJAZAk@lAvXiOP4sgD60fwP18XSEMAdBUUWftkQ7vMZUXrU218tSwsvZyYl8XIKuSMIXSiIztaU9YvdpmQPULdslgrKdZD2eVCicLNEl3o/1XIYQ3kQvfQdKXuZjJhRaR7UqQ3LGH8Mmaqgqe14HH8kNozFaLQK2VqZRaD4xuJ41Wc5PorsS90/7Ps/hjTlmfjxgWDWmrLMFXD3UatMkQN3Zmk@wyiKBsTJ1sNnLPJXqhwxjYT0lVGzzJGas9Xdr@Yp01a/6olH0ryz1k0E/PC/lnJH3BLxNZUZbfsZJ3ozbLiyHavhutziyuJpyWhKpxt6xTocEnntZw7ijrJ9nFy3Wywrpl58o5Wrixwe21xq7PDVp6azTZbtCR9rDYaG2I7JzyqGf8nFaJnNPniLFoIPwzZidmMhmz@PBAQ/GHaKLKGSbHZ7R0c3rx1@87db@nEg/lESbJcTBhP64XBPVcY3SK923W6Pm2qmQEqIOoJm4pZF97bXAcXGMW67pczUx2rN0ptJ6@PXj5rFCrV1FSqNetovW6A0Rv4DpGxp@okD5WUDnu4S20lZz25A71Mxw/5WswXVAReo4p0T00rvv8b7asRyt25kC4mPsXaBWJ@tbd2cWakdXpqKz0tJwJNcmUQ2lsgjHWEzOx4LxNcZgT7pL1yC@FYQ3NX0nyxDEWQhOsrE2t3i1j7apIK3gf@lxdAcrVLp8wP3pf3WLOcrh1utb@/LrzUOfxHxmNEkQZxpHO5HtHdIqdmulm860rDsb8M498s3iL2LxTv@leWDnhulu701FgPun0N611CQrvXZ4rauowtbYFNZnoULxLKgzSOajLTQOrgyc9LGgbiyoKo3dt1VoPB2t1sjfu6skhTIuY0ulIk97cBeaDrNgapil89lgcWFmOx7wNxFqSM7JPn8QzK35Acy@odnCKtseGvKrken1wqs/56cWa9oaarl4@vLKne2JJUf5Hcj19fGfNftjD/STL/xxVy/2ldsfexmDNeY1ihYiIQImTk5KoQYUG32u11d3e3hcWJxPJ9MCOXczOkijRX7oXulthivrpaMQ@2S/kqk/LVpaU8qBMyT76R4HFInobxWY2FO5LfX2goyrWlPjcr9D6XvZ@a87VnsYgL1fXmolee1A27o7oKtsJmrZSg90w386nbnf8sRh8ko5OzuH1G12S2gU313OWy9Ieq8AUimdKycW8Xm1bgCW4xFLfhbau/BQyDRPRJ0hmPUybwatZ47MD87OAWYPuttYELbvHWbAjmUiXisgKMcgEyc1y5BHu/QQLj9q947DF/yVlKbpAX1ONx3cTlqC0h07e4hgP23kXLuBwXbnAOsx1yKxRHan/TU2u4S2l9IWHZjIvIFvRrAXPwyB3IKXDupdDtqM0MeMoUty81nLPc4BayEEXoBUxT@06FqkJ/YGtdfHoGJGSqnNCicouteILgVU8Q5IEPbt0NLSMYWpg0bFL51hFKrK4E4abkorRFNbRUlm7aq6tuaKbmbCGnu21ftrJ3cyFLjMtu6YZdIu89FRlhP9y/B30luGmhoS7UzQm944TGcsHiCxlFJFb7uCSOoDY1u1km7I6Oa6LsOx1lMFdl3K@V5rEE3zrenOsrRKv8xKS76vW68KPvDzVPu0116tpslma9nDo5AWjTOIRJD4//qDcP2HuWKsR0wSDX07ClNTNh2GdKU6i3rcNTiajZ7LyNg@jSyPLDrbo9PTcDbkE9IsECfBWnGOYDwiBVHzAltQCbR5dAW6JBmAxkAfI@LvlhzWTR8cyOFxH0Hcj68xLyKgnjCBLDZCksEu8Z7hVJxQiwo8fwvHmx9OYWNaWODqDb9eJl6O/mKEkagwZTvLobT4H0dKrWKQLvnCo2KEhsUUuFHwMEHszmAmQCJeFlswSaYi6NgvmL0wWqJ1Vwj2DKiJoCdRG9wz4WOTadIndUEvwGfQipdyQEEsJMTiHWAPuUrOMlKBIwixg8mbGQTDljRXC5YEAHBnC8KvpN1Y@v5X6MO5QN6xz5PUaicuZUHoQ5qbst8JW/OE2yR5rEuBiQKW77ufjabZZcUvazvaroVAXIf5WQj1DTeW6HgIeYbOGKvpBcdKhfclMSzNcxF65rN5V/znkX1PVl/DW7wKmrmgOL1SP7nkJlP1eTcXq1C4GjEp20tnxZ9S@nGkgYo3KGMonyRZDW7dM@VjtCbLKc/a7uZY4zppAfB/q6OeP8gusC@qgZJJ9GkGT17MvVLX05EwV4agNKUx1aeA4Ds2Aq@fQLF7Oxxb49b27Zg@w8P3keI18Hv41QOn7GCbBwBI23aOKI2SfRWZOP@lb3efIbBOq6TnYRJ7u9M7LON9P8vXwakA8flYqOXj49loUfYoHOkoWyizbk7rhFdnfH474kkI9ymqcCggPqHf2h5/ZyB1nrcZZwKb46o1BlXHZu1/zPv/7dLGYHXQtAEV2sBlRZLWsBoKap2wVA1lNBKOHSKpFS9uUXOjppyFjidLq98tAvRC9Njt9F0QhhEpvEKTPXsKo2vCa/b4Jime@edB7y2RIT/Sv5xtx@0R071PfHVPdwdtrvd1pkp93WfOBhzsJksJM9q7Gk5gdm4SCOBjupgHluLKC43HG3cfIVJylCxodFeHNIO84CRP56HJsYXE3NqClLJfQKvA8F@pUlgvpKD0FVN42aYDy6uKYofyHN1OgRHEArp1JFtdttSG/k0fHjJwQSHTw27cVGKs/UfXAaWBJA99PIep1dTYd@pfJVEQeHgkzGhv2bB6UCmQFdNrx50C@W/CoIQnmTvuaqmaJKwP1OBSGbaG@gXxD49ZM3f3t@UhC4kLSM28pP0KJ0b95sNj91F33eefHpAznBS7weTUF2vBbdax2sDlc3V7dWt1d3VndX367oihySO43uDngG/Y58IMdLAfNXSnacHjmAd3fJLXKb3CE3ybek13V35KqDkoid4dyNRA9bd1c9IEr1P1jx3Kon2AVqPaAEfxziRz29Wy2khkCB0s1aSoeSzAG5VT/@No7s1Y68XT/mABRzsHnUAfA6qBnXaYC29er3038B) [Answer] # [Pip](https://github.com/dloscutoff/pip) `-xp`, 8 bytes ``` aRAba@Rb ``` Takes input as two command-line arguments: the list, and a list containing the two indices (0-based). [Attempt This Online!](https://ato.pxeger.com/run?1=m724ILNgebSSbkWBUuyCpaUlaboWKxKDHJMSHYKSIFyo6E3laKVoQ2sja2NrE2tTazNrc2sLa0trQ4NYJR0FpWhja_NYuAkA) ### Explanation The `-x` flag is for taking the arguments as lists rather than strings; the `-p` flag is for displaying the result as a list rather than concatenated together. ``` a ; In the first argument RA ; replace the items at indices given by b ; the second argument a ; with the values in the first argument @ ; at indices Rb ; reverse(second argument) ``` --- The straightforward version, which takes the indices as separate arguments, comes in at [9 bytes](https://ato.pxeger.com/run?1=m724ILNgebSSbkWBUuyCpaUlaboWKxMdkqysEh2SEyF8qPBNhWilaENrI2tjaxNrU2sza3NrC2tLa0ODWCUdBWMdBXOYfgA): ``` a@b::a@ca :: ; Swap a@b ; the item in a at index b a@c ; with the item in a at index c a ; Output the new value of a ``` [Answer] # [Python 2](https://docs.python.org/2/), 49 bytes ``` lambda a,b,c:a[:b]+[a[c]]+a[b+1:c]+[a[b]]+a[c+1:] ``` [Try it online!](https://tio.run/##Hcc7CoAwEAXAq6RU8grj34AnWbfYjYiCP8TG00dxujmfez72PE79EFfZdBQjUAQv5JUtCQVmK6TW@fBf/4fvHM9r2W8zJeSQo0CJCjUatOjgMoYpYJo0vg "Python 2 – Try It Online") [Answer] # [PHP](https://php.net/), 46 bytes ``` fn(&$a,$i,$j)=>[$a[$i],$a[$j]]=[$a[$j],$a[$i]] ``` [Try it online!](https://tio.run/##JY3BCsIwEETv@xU5LNLAHFqr1hKjHxIWSZHQFipBqr8ft/T0hjcDk8dcbo88ZuLkS3pXB47gCTxbfw8cA0@CDbOID3vArqU4Il6NN6HBES1OOOOCDlf0aGpxxFHLVjkou22dKl5h9MLwYB394uf5@i5ZrXXlDw "PHP – Try It Online") changes the array in place, 0 indexing My first shot was with `list`, but PHP has array destructuring since 7.1, so it ends up like the JS answer with lots of dollars (money money money!) [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 7 bytes ``` İṘZ(n÷Ȧ ``` [Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%C4%B0%E1%B9%98Z%28n%C3%B7%C8%A6&inputs=%5B3%2C7%5D%0A%5B1%2C2%2C3%2C4%2C5%2C6%2C7%2C8%2C9%2C10%5D&header=&footer=) This could almost certainly be a bit smaller, but I got smol brain and can't think of a good way to swap values. Explanation: ``` İ # Get the values at the indexes Ṙ # Reverse the values Z # Zip the values with the new indexes (n # For each value/index pair: ÷ # Split the value/index Ȧ # Put the value at that index ``` [Answer] # [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 99 bytes ``` 2`\d+ $* 1(,1); $1,$& (?<=(?=.;(?<-2>\d+,)(\d+))(1),(?(4)$)(?<-4>1)(,1)?;(\d+,))\d+ $1 .; ``` [Try it online!](https://tio.run/##PYyxDsIwDER3f0dAdjhQnKYtKLQZ@QmGItGBhQHx/8EECcnS@d75/Frfj@etbviy1Lhc7ztyntQz1Esmp3Bb4nKeuEwHn23bx9muIJ5NRFjFgwsncfJN02ygtUvm36G0r0rWp1o7jFkR0SGhx4ARR5yggQL63JlRCzT8x3jKfaNWMqfmhqbRSPwA "Retina 0.8.2 – Try It Online") Link includes test cases. Takes input in the form `a,b;L`. Explanation: ``` 2`\d+ $ ``` Convert the indices to unary. ``` 1(,1); $1,$& ``` Make a second copy of `b` so that we now have `b,a,b;L`. ``` (?<=(?=.;(?<-2>\d+,)(\d+))(1),(?(4)$)(?<-4>1)(,1)?;(\d+,))\d+ $1 ``` Match an integer in `L`, with index `$#4` equalling either `a` or `b` (using a .NET balancing group), then match the other index in `$#2`, and match the integer at that index as the replacement for this integer (also using a .NET balancing group). ``` .; ``` Delete `a` and `b`. [Answer] # [Red](http://www.red-lang.org), 33 bytes ``` func[l a b][swap at l a at l b l] ``` [Try it online!](https://tio.run/##PY7BCsIwDIbve4r/5klYq6vVwx7Ca8ih21oU6jbmxMevWauGQPj@L4QsfkhXP4C4CpcUXmNPEQ4d0/PtZrgVG@bRIXIK0@Jdf8N3C1RBihQ0DjiigcEJFmeomoVt0eIslLCq/80SmKKb7OTCljW/zGykC2mxujDTvNzHFfSY4pC/67Dbt8gYSsCcPg "Red – Try It Online") 1-indexed [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~24~~ 21 bytes 1-based indices, input is a list and a tuple of indices to reverse ``` Reverse~SubsetMap~##& ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7Pyi1LLWoOLUuuDSpOLXEN7GgTllZ7X9AUWZeiUNadLWhjpGOsY6JjqmOmY65joWOpY6hQa1OtbGOeW3sfwA "Wolfram Language (Mathematica) – Try It Online") -3 bytes thanks to att. [Answer] # [Core Maude](http://maude.cs.illinois.edu/w/index.php/The_Maude_System), 158 bytes ``` mod S is pr ARRAY{Nat,Nat0}(sort Array{Nat,Nat0}to A). var I J X Y : Nat . op s : A Nat Nat -> A . eq s(A:A,I,J)= insert(I,A:A[J],insert(J,A:A[I],A:A)). endm ``` ### Example Session ``` \\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|/ --- Welcome to Maude --- /\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\ Maude 3.1 built: Oct 12 2020 20:12:31 Copyright 1997-2020 SRI International Sat Oct 16 22:01:13 2021 Maude> mod S is pr ARRAY{Nat,Nat0}(sort Array{Nat,Nat0}to A). var I J X Y : Nat . op > s : A Nat Nat -> A . eq s(A:A,I,J)= insert(I,A:A[J],insert(J,A:A[I],A:A)). endm Maude> red s(0 \|-> 1 ; 1 \|-> 2 ; 2 \|-> 3 ; 3 \|-> 4 ; 4 \|-> 5 ; 5 \|-> 6 ; 6 \|-> 7 ; > 7 \|-> 8 ; 8 \|-> 9 ; 9 \|-> 10, 3, 7) . result A: 0 \|-> 1 ; 1 \|-> 2 ; 2 \|-> 3 ; 3 \|-> 8 ; 4 \|-> 5 ; 5 \|-> 6 ; 6 \|-> 7 ; 7 \|-> 4 ; 8 \|-> 9 ; 9 \|-> 10 Maude> red s(0 \|-> 3 ; 1 \|-> 8 ; 2 \|-> 1 ; 3 \|-> 4 ; 4 \|-> 10 ; 5 \|-> 10 ; 6 \|-> 10 ; > 7 \|-> 10, 0, 5) . result A: 0 \|-> 10 ; 1 \|-> 8 ; 2 \|-> 1 ; 3 \|-> 4 ; 4 \|-> 10 ; 5 \|-> 3 ; 6 \|-> 10 ; 7 \|-> 10 Maude> red s(0 \|-> 5 ; 1 \|-> 1 ; 2 \|-> 4 ; 3 \|-> 2 ; 4 \|-> 3, 0, 4) . result A: 0 \|-> 3 ; 1 \|-> 1 ; 2 \|-> 4 ; 3 \|-> 2 ; 4 \|-> 5 Maude> red s(0 \|-> 5 ; 1 \|-> 6, 0, 1) . result A: 0 \|-> 6 ; 1 \|-> 5 Maude> red s(0 \|-> 2 ; 1 \|-> 2 ; 2 \|-> 2, 0, 1) . result A: 0 \|-> 2 ; 1 \|-> 2 ; 2 \|-> 2 ``` ### Ungolfed ``` mod S is pr ARRAY{Nat,Nat0} (sort Array{Nat,Nat0} to A). var I J X Y : Nat . op s : A Nat Nat -> A . eq s(A:A, I, J) = insert(I, A:A[J], insert(J, A:A[I], A:A)) . endm ``` The answer is obtained by reducing the function `s` with the list, given as a Maude array (e.g., `0 \|-> 1 ; 1 \|-> 2` for `[1, 2]`), and the two indices, zero-indexed. Maude does have lists (e.g., `0 1` for the same list `[1, 2]`), but this is one case where it's actually shorter to use arrays (which are generally very verbose) because we don't need to use an array literal syntax in the code, and because we need indexing. The FAQ says [it's allowed to accept input as either an array or a list](https://codegolf.meta.stackexchange.com/a/16670/45870). [Answer] # Javascript 38 bytes ``` (l,a,b)=>(l[a]=[l[b],l[b]=l[a]][0])&&l ``` [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` è¹Rǝ ``` Since no one posted an 05AB1E answer yet and it's been a couple of days, I'm gonna post my prepared 4-byter. First input is a pair of indices \$[a,b]\$, second input is the list \$L\$. [Try it online](https://tio.run/##yy9OTMpM/f//8IpDO4OOz/3/P9pYxzyWK9pQx0jHWMdEx1THTMdcx0LHUsfQIBYA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfWWCS9Ghlf8Przi0Luj43P86/6Ojo411zGN1og11jHSMdUx0THXMdMx1LHQsdQwNYmN1FKKjDXRMgfLGQDFDoLyhARzBpE2A0qZgSaARMEFDsKAZMtcIKG8UGxsLAA). Explanation: ``` è # Index the first (implicit) input into the second (implicit) input-list ¹ # Push the first input-indices again R # Reverse them ǝ # Insert the values at those reversed indices into the (implicit) second input-list # (after which the result is output implicitly) ``` ]
[Question] [ Write a piece of code that takes a string as input, and outputs a piece of code in the same language that, when run, will output the initial input string. It must be able to handle any combination of characters A-Z, a-z, and 0-9. Example in Python: ``` import sys print "print('" + sys.argv[1] + "')" ``` Given the input of `testing123`, it will return `print('testing123')`. Since this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest answer in bytes will win. [Answer] # [pl](https://github.com/quartata/pl-lang), 0 bytes ### Code: [Try it online!](https://tio.run/##K8j5DwQlqcUlAA "pl ‚Äì Try It Online") ### Explanation: An empty program in pl is simply a cat program, outputting the exact same as the input. In pl, all ASCII characters are essentially variables, but when the variable doesn't exist (yet), pl assumes that they are part of a string. [Answer] # [brainfuck](https://github.com/TryItOnline/brainfuck), ~~56~~ ~~55~~ 33 bytes 1 byte saved thanks to Gravitron, and 22 bytes saved thanks to Jo King! ``` --[>+<++++++],[[->.<]>+++.--.-<,] ``` [Try it online!](https://tio.run/##SypKzMxLK03O/v9fVzfaTttGGwxidaKjde30bGLtgBw9XV09XRud2P//PVJzcvJ1FMLzi3JSFAE "brainfuck ‚Äì Try It Online") Output requires an interpreter that wraps on memory underflow and has EOI=0. TIO has such an interpreter. ## Explanation `--[>+<++++++]` initializes the tape with a single `+`. The input loop: ``` ,[[->.<]>+++.--.-<,] , take input [ ,] while input is nonzero: [->.<] output `+` input times >+++. output `.` (`+` + 3) --. output `,` (`.` - 2) -< restore `+` and move back to input ``` ## Other solutions Each line is its own solution. ``` +++[>+++++<-]>[>++++>+++<<-]>>-->,[[-<.>]<+++.---<.>>,] --[>+<++++++],[[->.<]>+++.++++++++++++++++.-------------------<,] ++++++++++[>++++++>++++>++++<<<-]>>+++>++++++>,[[-<<.>>]<.<<.>>>,] ++++++++++[>++++++>++++>++++<<<-]>++>+++>++++++>,[[-<<.>>]<.<<.>>>,] ``` [Answer] # [Mornington Crescent](https://github.com/padarom/esoterpret), 27640 bytes ``` Take Northern Line to Moorgate Take Circle Line to Moorgate Take Circle Line to Westminster Take Circle Line to Hammersmith Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Barbican Take Circle Line to Victoria Take Circle Line to Victoria Take Victoria Line to Seven Sisters Take Victoria Line to Victoria Take Circle Line to Victoria Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Bayswater Take District Line to Barons Court Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Gunnersbury Take District Line to Mile End Take District Line to Cannon Street Take Circle Line to Moorgate Take Circle Line to Hammersmith Take Circle Line to Cannon Street Take Circle Line to Hammersmith Take Circle Line to Cannon Street Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Mile End Take District Line to Barking Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Bank Take Circle Line to Bank Take Northern Line to Charing Cross Take Northern Line to Charing Cross Take Bakerloo Line to Paddington Take Circle Line to Royal Oak Take Circle Line to Tower Hill Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Mile End Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Bank Take Circle Line to Baker Street Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Baker Street Take Circle Line to Bank Take Circle Line to Bank Take District Line to Barking Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Liverpool Street Take Circle Line to Bank Take District Line to Barking Take District Line to Bank Take District Line to Gunnersbury Take District Line to Upminster Take District Line to East Ham Take District Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Sloane Square Take District Line to Gunnersbury Take District Line to Hammersmith Take Circle Line to Cannon Street Take District Line to Gunnersbury Take District Line to Mile End Take District Line to East Ham Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Plaistow Take District Line to Mile End Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take District Line to Barking Take District Line to Bank Take District Line to Barking Take District Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Wood Lane Take Circle Line to Liverpool Street Take Circle Line to Bank Take Circle Line to Liverpool Street Take Circle Line to Hammersmith Take Circle Line to Paddington Take District Line to Barking Take District Line to Bank Take District Line to Barking Take District Line to Hammersmith Take District Line to Gunnersbury Take District Line to Dagenham East Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Mile End Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Mile End Take District Line to Victoria Take Circle Line to Bank Take Circle Line to Victoria Take Circle Line to Hammersmith Take District Line to Mile End Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Upminster Take District Line to Mile End Take Central Line to Bank Take Circle Line to Victoria Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Wood Lane Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take District Line to Elm Park Take District Line to Bank Take Circle Line to Wood Lane Take Circle Line to Bank Take Circle Line to Bank Take District Line to Barking Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take District Line to Barking Take District Line to Bank Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Bank Take Central Line to Northolt Take Central Line to Bank Take Circle Line to Bank Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Mile End Take District Line to Barons Court Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take District Line to Upminster Take District Line to Mile End Take District Line to Wimbledon Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Wood Lane Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Tower Hill Take Circle Line to Bank Take Circle Line to Wood Lane Take Circle Line to Bank Take Circle Line to Bank Take District Line to Barking Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take District Line to Barking Take District Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Bank Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Mile End Take District Line to Upminster Take District Line to Bank Take Circle Line to Baker Street Take Circle Line to Bank Take Circle Line to Bank Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Bakerloo Line to Waterloo Take Northern Line to Bank Take Circle Line to Bank Take Central Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Wood Lane Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Blackfriars Take Circle Line to Bank Take Circle Line to Wood Lane Take Circle Line to Bank Take District Line to Barking Take District Line to Paddington Take Circle Line to Bank Take Circle Line to Victoria Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Victoria Take Circle Line to Wood Lane Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Wood Lane Take Circle Line to Bank Take Circle Line to Paddington Take Circle Line to Victoria Take Circle Line to Victoria Take Victoria Line to Euston Take Victoria Line to Victoria Take Circle Line to Victoria Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Wood Lane Take Circle Line to Paddington Take Circle Line to Bank Take Central Line to Northolt Take Central Line to Bank Take District Line to Southfields Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Baker Street Take Circle Line to Bank Take Circle Line to Bank Take District Line to Upminster Take District Line to Ravenscourt Park Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Mile End Take District Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take District Line to Upminster Take District Line to Mile End Take Central Line to Bank Take Circle Line to Bank Take Northern Line to Old Street Take Northern Line to Bank Take Circle Line to Bank Take District Line to Gunnersbury Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take District Line to Mile End Take Central Line to Theydon Bois Take Central Line to Mile End Take District Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Bank Take Northern Line to Old Street Take Northern Line to Bank Take Circle Line to Bank Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Mile End Take District Line to Acton Town Take Piccadilly Line to Cockfosters Take Piccadilly Line to Acton Town Take District Line to Acton Town Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Wood Lane Take Circle Line to Paddington Take Circle Line to Wood Lane Take Circle Line to Bank Take District Line to Elm Park Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bayswater Take Circle Line to Paddington Take Circle Line to Bayswater Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bayswater Take Circle Line to Bank Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Bank Take District Line to Barking Take District Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bayswater Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bayswater Take District Line to Barking Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Barbican Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Barbican Take Circle Line to Bank Take Circle Line to Bank Take District Line to East Ham Take District Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take District Line to Elm Park Take District Line to Bank Take Central Line to Chancery Lane Take Central Line to Bank Take Circle Line to Bank Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Bank Take District Line to Plaistow Take District Line to Bank Take Circle Line to Hammersmith Take District Line to Mile End Take Central Line to Bank Take Circle Line to Bank Take Circle Line to Farringdon Take Circle Line to Bank Take Circle Line to Bank Take Central Line to Mile End Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Bank Take Northern Line to Brent Cross Take Northern Line to Bank Take Circle Line to Bank Take Central Line to Mile End Take District Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take Circle Line to Notting Hill Gate Take Circle Line to Notting Hill Gate Take District Line to Upminster Take District Line to Mile End Take District Line to Paddington Take Circle Line to Farringdon Take Circle Line to Bank Take Circle Line to Tower Hill Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Farringdon Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Farringdon Take Circle Line to Bank Take Circle Line to Bank Take District Line to Southfields Take District Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take District Line to Elm Park Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take District Line to Elm Park Take District Line to Paddington Take Circle Line to Blackfriars Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Royal Oak Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take District Line to Barons Court Take District Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Blackfriars Take Circle Line to Paddington Take Circle Line to Blackfriars Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Royal Oak Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Farringdon Take Circle Line to Paddington Take Circle Line to Paddington Take District Line to Southfields Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Embankment Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take District Line to East Ham Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take District Line to East Ham Take District Line to Bank Take District Line to Barking Take District Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Barbican Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take District Line to West Ham Take District Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take District Line to Barons Court Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Victoria Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Wood Lane Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Aldgate Take Circle Line to Paddington Take Circle Line to Aldgate Take Circle Line to Hammersmith Take Circle Line to Paddington Take District Line to Barking Take District Line to Paddington Take Circle Line to Bank Take District Line to Barking Take District Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Bank Take District Line to Barking Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Moorgate Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Aldgate Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Central Line to Chancery Lane Take Central Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take District Line to Barking Take District Line to Paddington Take Circle Line to Westminster Take Circle Line to Paddington Take District Line to Plaistow Take District Line to Bank Take Circle Line to Moorgate Take Circle Line to Hammersmith Take Circle Line to Bank Take Northern Line to Charing Cross Take Northern Line to Charing Cross Take Northern Line to Bank Take Circle Line to Bank Take Circle Line to Paddington Take Circle Line to Westminster Take Circle Line to Paddington Take Circle Line to Hammersmith Take Circle Line to Aldgate Take Circle Line to Temple Take Circle Line to Hammersmith Take District Line to Mile End Take Central Line to Bank Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Bank Take Circle Line to Westminster Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Mile End Take Central Line to Bank Take Circle Line to Bank Take Northern Line to Charing Cross Take Northern Line to Charing Cross Take Northern Line to Bank Take Circle Line to Tower Hill Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take Circle Line to Notting Hill Gate Take Circle Line to Notting Hill Gate Take District Line to Upminster Take District Line to Tower Hill Take Circle Line to Bank Take Circle Line to Temple Take Circle Line to Bank Take Circle Line to Bayswater Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Bayswater Take Circle Line to Tower Hill Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take Circle Line to Notting Hill Gate Take Circle Line to Notting Hill Gate Take District Line to Upminster Take District Line to Bank Take Circle Line to Hammersmith Take Circle Line to Embankment Take Circle Line to Hammersmith Take Circle Line to Tower Hill Take Circle Line to Bank Take Circle Line to Embankment Take Northern Line to Angel Take Northern Line to Bank Take Central Line to Marble Arch Take Central Line to Bank Take Circle Line to Bank Take Circle Line to Westminster Take District Line to Upminster Take District Line to Bank Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Bank Take Circle Line to Aldgate Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Mile End Take Central Line to Bank Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Mile End Take Central Line to Bank Take Circle Line to Bank Take Northern Line to Charing Cross Take Northern Line to Charing Cross Take Northern Line to Bank Take Circle Line to Tower Hill Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take Circle Line to Notting Hill Gate Take Circle Line to Notting Hill Gate Take District Line to Upminster Take District Line to Embankment Take Circle Line to Bank Take Circle Line to Hammersmith Take Piccadilly Line to Bounds Green Take Piccadilly Line to Hammersmith Take Circle Line to Embankment Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Cannon Street Take Circle Line to Hammersmith Take Circle Line to Cannon Street Take District Line to Acton Town Take District Line to Acton Town Take Piccadilly Line to Bounds Green Take Piccadilly Line to Holborn Take Central Line to Holborn Take Central Line to Bank Take Circle Line to Hammersmith Take District Line to West Ham Take District Line to Bank Take Circle Line to Aldgate Take Circle Line to Aldgate Take Metropolitan Line to Chalfont & Latimer Take Metropolitan Line to King's Cross St. Pancras Take Victoria Line to Seven Sisters Take Victoria Line to Euston Take Victoria Line to Euston Take Northern Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Bank Take Circle Line to Tower Hill Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Stepney Green Take District Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Stepney Green Take Hammersmith & City Line to Moorgate Take Circle Line to Moorgate Take Metropolitan Line to Chalfont & Latimer Take Metropolitan Line to Moorgate Take Circle Line to Moorgate Take Circle Line to Bank Take Circle Line to Bank Take District Line to Upminster Take District Line to Bank Take Circle Line to Tower Hill Take Circle Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take Piccadilly Line to Russell Square Take Piccadilly Line to Russell Square Take Piccadilly Line to Acton Town Take District Line to Acton Town Take District Line to Bank Take Circle Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Bank Take District Line to East Ham Take District Line to Bank Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take District Line to East Ham Take District Line to Tower Hill Take Circle Line to Bank Take District Line to West Ham Take District Line to Bank Take Circle Line to Bank Take Northern Line to Angel Take Northern Line to Bank Take Circle Line to Moorgate Take Circle Line to Bank Take Circle Line to Hammersmith Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Bank Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Barbican Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Moorgate Take Circle Line to Bank Take Northern Line to Morden Take Northern Line to Bank Take Circle Line to Bank Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Victoria Take Victoria Line to Seven Sisters Take Victoria Line to Victoria Take Circle Line to Victoria Take District Line to Mile End Take District Line to Embankment Take Northern Line to Kennington Take Northern Line to Bank Take Circle Line to Bank Take Central Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Liverpool Street Take Circle Line to Paddington Take Circle Line to Paddington Take Circle Line to Aldgate Take Metropolitan Line to Croxley Take Metropolitan Line to Aldgate Take Circle Line to Aldgate Take Circle Line to Bank Take Circle Line to Bank Take District Line to Gunnersbury Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Hammersmith Take District Line to Gunnersbury Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to West Brompton Take District Line to Gunnersbury Take District Line to Mile End Take District Line to Acton Town Take District Line to Mile End Take District Line to Paddington Take Circle Line to Paddington Take Circle Line to Victoria Take Victoria Line to Seven Sisters Take Victoria Line to Victoria Take Circle Line to Victoria Take District Line to Mile End Take District Line to Acton Town Take District Line to Acton Town Take Piccadilly Line to Hounslow Central Take Piccadilly Line to Acton Town Take District Line to Acton Town Take District Line to Mile End Take District Line to Gunnersbury Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Gunnersbury Take District Line to Paddington Take Circle Line to Bank Take Circle Line to Bank Take Northern Line to Mornington Crescent ``` [Try it online!](https://tio.run/##7V3dduMmEL7vU@iqvWrfIfamyTkb7@6J0@YaSyTmGIELOKmffouztde2JBA/A1LimxzHIDQMMx/zB665YIQ9K85@LwWWJWbq@/cHtMLFFy7UEgtW3BGGC8WLGefiGSn8y1vzlIiS4n6Nj1iqmjCpsGhtv0V1jYWsiVq2tl/RqnPsCWKrjgaxICVirY1/k1JxQVCPxv1/h@Y5fsGsmJPddGRHH4fx@86nwaRPmgKhhzr0@Gt9wuRG@wRt5SsytQvOZDHlG6E6utxsGNNELDZi29HDTqZ9jBnR875mVUfzFDHG9QoogbFyl0abtNmHDx8hYJUtzNGLuNIK7b06NiEKbY8hxp0av29oYNd0iYTmSjEVXMr@fSb6j6CcH/p8Q1X1Ay5bKbjnW0SLr6idvgf@ikVxSyjNql2WOVia4SXIIuDwBNhZaBBBLTBAih@Mm2ELDzDnnw2OMNafi25zvCMvWKw5p/2m4021x9rahPYaSbWbPpjWhI8ADU1zypH@NP9ngwSOB7H2zT2@qlpWE1TRkyw0Rfor/uo3v@iCFE@RHc0vt5V55Lwq7rSMxwAvn6dd6c/GVw@R@YSeMVui@k333q1xFcPEHL6LkBo/MiBodjvcL4phfCrY@c2/sOGG3OkUp5gpoX3KMMYCBpXeA1wM1bMy7/fRnKCm9Ulr3UmsXL0vT3oH5wYmIAgAOJzCFmew8hYM41Q5gk6QR5t7jwU3M3rE0@PiSuwJPJJ6QXHVOfy7RkVL8BaY2gsmfhDbA3TLCDaoA3IxAEHh6HtKI7/zuEuP6i86UkQ9iD7fOz8SRk4oKldP2gnZ58Vjk@sIPb7ci@RLuTEPhFgzY31faZupp/RZyAmp2bjeyMOwEYs1oBjoavvGDCP3n5OnD9FQ0znfqOUTwbSSY0qMDy7/BbLn2iZ1j14wk@XOxzHFDFIENIPDOGOwSAflMXoECho21Vdancisj9GVPaLnyKeHJd5qt7qYcCK9zMYRRD/Aqk3SSlJ2Pl5p@4Ptwg//M@obKUtUEUq3P0sSuDa7@VE9akuf82Gs70m73kE2ibf74BvoDo6lnBTixnw4WpQnRgk2KJvikpqrpCNIFGDdhB7l4lnjkC71/iOhxgRVjvV9sKISgKRnhs50iViJxfYYv5Okn4ZQazOAOpKYWUXXMr9opyA8JOas4U8kdsX/lb856mjBwwcD3A3oidBzMJ6RiM@HMfjcNnT8wpXanRzZZQeLmy7bo6NXYr/LV9B9859QG6zvPIZGT1BcdDy7fqpctIUiqAQWlFSZD5TlyfXbalryJjdsSwj7eND5wLCxLQAUGtC0g1GmxOh1vdAvrrXVAZp1dXXIhpYmThLA8WdS6qjLMIMIzQo8PCSv3605R8iwzwEk2/6VNegWUgORMQIfIAoBjwIfR4OqiBx@JWbUxTdexgGxnWXV0GTbe8Q4agLQ9Vcz2@VB1rf7BiGDLpGJfxeJVyzObQdw5HTEW5wecL2mOG0sOI59EvP2ENsCJLw8JEZlD7igW2KSl9CyKzW@QV6D@hoExyu7n8l9NlMbLTh@kdBox2XcwkS2x31X@Py1DXC7Ys@Y2oHvPKmGxEK/5UqUy1gZ0MbmE29tgHZaEHoybqVAbLps7BfYtKBff@lqqSyd8A2rZHEjMO4uUQ2EZ2/YB7nM0712tkcRbz82crrggrWrsrExAEAsQWgvPDtpm2El@JpTotAJgNAnzlTxa3GHFKn3st3a@bNWkt/kD7DRS/WHtvNYKZAMuMLXeGTsuLE/rI0Bt@ALQEZ4SHuu8Jrh7bFyjrKQqWUeRy/VmjYlautz4Xe4BvvfLg5xquMjaEHL9nK/kRJrS@P4Ck3/buFHTt41qARV1karPshYmOo6qd66F82CMfhAPf32GDiWKeQVOqyhkgIwoWhYshkXFWZJT5mOwSiAVvi0P6fhfNOyLUD3GTN2PLvBXwrT6ybfiPUc7baf4P9SvDX06O0dJrk4KLeSpLggMIXJ8rbTTgSv190J@eDD@XmPKg8bz2KEom75hknKX/e4le9Q@ce4rjoYXHwM2Nnhl780WO9/@es/ "Mornington Crescent ‚Äì Try It Online") ## Explanation First, a quick refresher on Mornington Crescent: * each station can either hold a string of arbitrary length or a bigint * there's also an accumulator which also holds a string or a bigint * all stations start with their own name as their value * at the beginning, the accumulator contains your program's input * each time you go to a station, the station's value and the accumulator are swapped * some stations are special and override this behavior * the line you use to get to a station doesn't matter * you start at Mornington Crescent * to end the program, you go to Mornington Crescent too * at the end, the value of the accumulator is printed Since printing strings is hard (see [Martin Ender's Mornington Crescent "Hello, World!" program](https://codegolf.stackexchange.com/a/57064/55934)), we will need a simple template that can be used to output generic strings. Since the length of the generated programs don't matter, I've settled on this: ``` Take Northern Line to Bank Take Northern Line to Bank Take District Line to Paddington ``` We'll need to generate each character separately and concatenate them, since the substring approach used by Martin is much harder to implement in the general case. Paddington is the station that performs string concatenation. When you arrive at Paddington, the following happens: ``` accumulator, paddington = paddington + accumulator, accumulator ``` This behavior is used to initialize Paddington to the empty string that's assumed to be the input. ``` Take District Line to Victoria Take Victoria Line to Seven Sisters Take Victoria Line to Euston Take Victoria Line to Euston Take Northern Line to Bank ``` Go to Seven Sisters, which sets the accumulator to 7, and store it in the Bank. The Bank is the only way to copy values - Hammersmith is a readonly copy of Bank's value. ``` Take District Line to Hammersmith Take District Line to Cannon Street Take District Line to Hammersmith Take District Line to Cannon Street Take District Line to Bank ``` Divide 7 by 7 to get 1, a divisor of all ASCII values we need to support. ``` Take District Line to Hammersmith Take District Line to Upminster ``` For each character, start by copying the 1 to Upminster. ``` Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster Take District Line to Hammersmith Take District Line to Upminster Take District Line to Upminster ``` Add more ones as necessary. ``` Take District Line to Hammersmith Take District Line to Upminster Take District Line to Bank Take District Line to Bank Take Northern Line to Charing Cross Take Northern Line to Charing Cross Take Bakerloo Line to Paddington Take Bakerloo Line to Paddington Take Bakerloo Line to Charing Cross Take Northern Line to Embankment ``` Finish up by going to Upminster only once, to keep the new value in the accumulator instead of storing it again. Take it to Charing Cross to turn the ASCII value into a character and append it to the string. The last two lines are there because I've misread the specification, so I'll stop here and golf my program down first. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 1 byte ``` ·πæ ``` Woo builtins! The builtin `·πæ` unevals the input. [Try it online!](https://tio.run/##y0rNyan8///hzn3///9XCkktLsnMSzc0MlYCAA "Jelly ‚Äì Try It Online") A more interesting one: ``` ‚Åæ‚Äú‚Äùj ``` Joins the string "‚Äú‚Äù" by the input. [Try it online!](https://tio.run/##y0rNyan8//9R475HDXMeNczN@v//v1JIanFJZl66oZGxEgA "Jelly ‚Äì Try It Online") [Answer] # Charcoal, 1 byte ``` Œ∏ ``` By default, a string of ASCII characters .. `~` simply prints itself, so it just remains to print the input. [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~89~~ ~~87~~ ~~58~~ 56 bytes Saved two bytes thanks to Jakob! ``` main(a,c)charc;{printf("main(){puts(\"%s\");}",c[1]);} ``` [Try it online!](https://tio.run/##S9ZNT07@/z83MTNPI1EnWTM5I7FISyvZurqgKDOvJE1DCSyjWV1QWlKsEaOkWhyjpGldq6STHG0YC2T8//@/JLW4JDMv3dDIGAA "C (gcc) ‚Äì Try It Online") [Answer] # [Japt](https://github.com/ETHproductions/japt), 2 bytes ``` iQ ``` [Try it online!](https://tio.run/##y0osKPn/PzPw/3@lzLyC0pLikqLMvHQlAA "Japt ‚Äì Try It Online") `i` is a function that inserts a specified string at a specified index into the input. `Q` is a variable that defaults to a quotation mark `"`, and since there's no index given, this defaults to `0`. The end result is a quotation mark inserted at the beginning of the string, which Japt auto-finishes when running. This works on strings containing anything except `"`, `{`, or `\`, though of course the string is guaranteed to consist of alphanumeric chars so this doesn't matter. [Answer] # [Python 2](https://docs.python.org/2/), 22 bytes ``` print'print%r'%input() ``` [Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EHUyqFqmrZuYVlJZoaP7/r16SWlySmZduaGSsDgA "Python 2 ‚Äì Try It Online") [Answer] # MATLAB / [Octave](https://www.gnu.org/software/octave/), 15 bytes ``` @(t)['disp ',t] ``` [Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999Bo0QzWj0ls7hAQV2nJPZ/moZ6SWpxSWZeuqGRsbomF1gGIfIfAA "Octave ‚Äì Try It Online") I completely overlooked the fact that the program only needs to handle alphanumeric characters, or, importantly, does not need to handle space characters. This means we can use the 'command' syntax, which uses significantly less bytes. ### MATLAB, 27 bytes For completeness, here's a version that can handle arbitrary input: ``` @(t)['disp(',mat2str(t),41] ``` Defines an anonymous function taking the string `t`, and converts it to the program. Curiously, this does not work in Octave, which seems to have different ideas of what `mat2str` should do. [Answer] # PowerShell, 9 Bytes ``` "'$args'" ``` single or double quotes in powershell can be used to contain strings, but only double-quotes allow variable expansion. with an input of `foo` this will output `'foo'` which is a valid powershell program which outputs `foo` [Answer] # [Befunge-98 (FBBI)](https://github.com/catseye/FBBI), ~~21~~ ~~16~~ 12 bytes -5 bytes thanks to [NieDzejkob](https://codegolf.stackexchange.com/users/55934/niedzejkob) -4 bytes thanks to [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king) ``` #,~'',,',,'@ ``` [Try it online!](https://tio.run/##S0pNK81LT9W1tPj/X1mnTl1dRweEHP7/L0ktLsnMSzc0MgYA "Befunge-98 (FBBI) ‚Äì Try It Online") Outputs `'t,'e,'s,'t,@` for an input of `test` ### How? Initially the pointer moves East: ``` #, # skips the next instruction ~ push a byte of input '', push ' and print it , print the byte of input ',, push , and print it '@ push @ to the stack ``` If there is no more input left, `~` reverses the direction of the pointer: ``` , print @ # skip nothing @ terminate ``` [Answer] # [Emojicode](http://www.emojicode.org/), 88 bytes ``` üêñüòç‚û°Ô∏èüî°üçáüçéüç™üî§üèÅüçáüòÄ‚ùåüî§üî§üêïüî§‚ùåüî§üçâüî§üç™üçâ ``` [Try it online!](https://tio.run/##S83Nz8pMzk9J/f9h/oRuhQ/zpywEEr3tIO60D/Nn9D6at/D9jn6QOEgYiPuAeBWQv@TD/P5GiNiMhkdzeyBCIDxhKoiGC/V2QulVIPZ/EMEF08ulANINsgdk9ZLEvMrgkqLMvHQQhwusHAA "Emojicode ‚Äì Try It Online") Input: ``` anyString ``` Output: ``` üèÅüçáüòÄüî§anyStringüî§üçâ ``` Script Output:** ``` anyString ``` [Answer] # [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 7 bytes ``` ?@?@`+; ``` ## Explanation ``` ? PRINT on the screen @ ` a literal ?@ question mark and at +; and append the input ``` ## Sample run ``` Command line: lala ?@lala ``` The output is a string literal containing the input, preceded with a `PRINT` command. [Answer] # [Batch](https://en.wikipedia.org/wiki/Batch_file) 11 bytes I'm sure there's away to get it smaller, but this is pretty small. ``` set/p=echo ``` ### The breakdown: ``` set ::Define new variable /p ::Create prompt = ::Define a variable in prompt echo ::Prompt begins with 'echo ' ``` ## In English: The user is asked for input with a leading phrase `echo`. Then the user may type in whatever, and the program terminates (e.g; `echo hello world!`). This leaves us with a program that when ran, will output `hello world!`. Yes, the whitespace is supposed to be there [Answer] # V, 2 bytes ``` ii ``` In Vim, `i` changes to insert mode and allows inserting text. In this case, it just inserts the `i` in front of the input text (to create the second program). V is Vim compatible, but adds an implicit `<esc>` to the end of the program, so I don't need to worry about it here. [Answer] # [Cubically](https://github.com/aaronryank/cubically), 87 bytes ``` U3D1R3L1F3B1U1D3~:7+1(-1@3(-1%1)6:1+3111@6%1-31111+004@6:1+11111%6:1+45@6:1-1%6~:7+1)6 ``` [Try it online!](https://tio.run/##Sy5NykxOzMmp/P8/1NjFMMjYx9DN2Mkw1NDFuM7KXNtQQ9fQwRhIqBpqmlkZahsbGho6mKka6oIYhtoGBiYOIGEQx1AVxDIxBQkA1ZuBtWuaKfz/75Gak5OvoxCeX5SToggA "Cubically ‚Äì Try It Online") A port of my answer [here](https://codegolf.stackexchange.com/a/137695/71434). There already existed a challenge to take input and output Cubically code that produced that input, and I had an answer in Cubically so... profit? [Answer] # D, ~~92~~ 89 bytes ``` void main(){import std.stdio;write(`void main(){import std.stdio;"`~readln~`".write;}`);} ``` [Try it online!](https://tio.run/##S/n/vyw/M0UhNzEzT0OzOjO3IL@oRKG4JEUPiDPzrcuLMktSNRLwqlFKqCtKTUzJyatLUNIDa7CuTdC0rv3/Pzgk1M0NAA) [Answer] # SmileBASIC, 21 bytes Maybe this is cheating... ``` LINPUT"?"+CHR$(34);S$ ``` Asks for input with the prompt `?"`. (? is short for PRINT, and closing quotes are not required). So the "output" program is `?"<text>` [Answer] # [Python 2](https://docs.python.org/2/), 17 bytes ``` 'print%r'.__mod__ ``` [Try it online!](https://tio.run/##K6gsycjPM/qfZhvzX72gKDOvRLVIXS8@Pjc/JT7@P1hAIU1DvSS1uERdkwvM50qtSE1GCP4HAA "Python 2 ‚Äì Try It Online") [Answer] # [SOGL V0.12](https://github.com/dzaima/SOGL), 2 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md) ``` $+ ``` [Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JTJDJTI0Kw__,inputs=aGVsbG8_) (expects input on stack so `,` is added for ease-of-use) `$` pushes `‚Äù`, `+` joins that after the input on the stack. [Answer] # [Perl¬†6](https://perl6.org), 19 bytes ``` say "say "~get.perl ``` [Try it](https://tio.run/##K0gtyjH7/784sVJBCUzUpaeW6BUARf//d8vPBwA "Perl 6 ‚Äì Try It Online") This should work for any Unicode input in NFC [Answer] # [8th](http://8th-dev.com/), ~~34~~ 37 bytes Code ``` : f >s "\"" tuck s:+ s:+ " ." s:+ . ; ``` Example ``` ok> "Print 42" f "Print 42" . ok> "Print 42" . Print 42 ``` [Answer] # [PHP](https://php.net/), 12 bytes ``` <?=$argv[1]; ``` [Try it online!](https://tio.run/##K8go@P/fxt5WJbEovSzaMNb6////JanFJZl56YZGxgA "PHP ‚Äì Try It Online") This is to be run from the command line with the input as the parameter argument. And yes, it simply outputs the input string‚Äîbut that is valid PHP: anything outside the `<?php` `?>` delimiters is output unprocessed. Here is the script produced by the 'testing123' input in action as a demonstration: [Try it online!](https://tio.run/##K8go@P@/JLW4JDMv3dDI@P9/AA "PHP ‚Äì Try It Online") [Answer] # [MATL](https://github.com/lmendo/MATL), 2 bytes ``` &D ``` [Try it online!](https://tio.run/##y00syfn/X83l/3/1ktTiksy8dEMjY3UA "MATL ‚Äì Try It Online") Simply wraps the string in quotes using `&D`, which is MATL's equivalent to MATLAB's `mat2str`, a function specifically made to make something that, when `eval`'d, will give the original matrix (or in this case, string). The resulting 'program' is just the input string wrapped in quotes, which is thus pushed on the stack, and implicitly displayed. [Answer] # [eacal](https://github.com/ConorOBrien-Foxx/eacal), 38 bytes ``` strap string put string put strap arg ``` [Try it online!](https://tio.run/##S01MTsz5/7@4pCixQAFIZualKxSUlsCYXFA2UDKxKP3///8lqcUlQAlDI2MA "eacal ‚Äì Try It Online") Simply appends the string `put string` to the memory string, then appends the argument, which is printed. [Answer] ## Batch, 14 bytes ``` @echo @echo(%* ``` Works for special characters too if they are quoted using `"`s rather than `^`. [Answer] # [Ly](https://esolangs.org/wiki/Ly), 14 bytes ``` "\""&i"\"&o"&o ``` [Try it online!](https://tio.run/##y6n8/18pRklJLRNIquUD0f//JanFJQA) ### Explanation ``` "\""&i"\"&o"&o "\"" # push `"` &i # take input "\"&o" # push `"&o` &o # output stack # test -> "test"&o # "test"&o = push "test" and output stack ``` [Answer] # JavaScript ES6, 25 bytes (outputs code to "standard output") ``` s=>alert(`alert('${s}')`) ``` # JavaScript ES6, 23 bytes (returns code, that outputs to "standard output") ``` s=>`alert('${s}')` ``` # JavaScript ES6, 14 bytes (returns a function, that returns the result) ``` s=>`_=>"${s}"` ``` [Answer] # [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~92~~ 68 bytes -22 bytes thanks to [Wheat Wizard](https://codegolf.stackexchange.com/users/56656/wheat-wizard) Includes +2 for `-cr` ``` {<>(((((()()()()()){}){}){})())<>{({}[()])<>((({}[()])()))<>}{}}<> ``` [Try it online!](https://tio.run/##SypKzMzTTctJzP7/v9rGTgMMNGFQs7oWioBsG7tqjeraaA3NWE2wQigbKAPk11bX1trY/f@fmJT8Xze5CAA "Brain-Flak ‚Äì Try It Online\" It Online") ``` # For every character { # Put ")(" on the off stack <>(((((()()()()()){}){}){})())<> # for 0 to the ASCII value of this character {({}[()]) # Replace the ")" with "(" and add "))" <>((({}[()])()))<> # End for }{} # end for and switch to the off stack for printing (in reverse order because of -r) }<> ``` [Answer] # [Pyth](https://github.com/isaacg1/pyth), ~~2~~ 1 byte ``` z ``` [Try it online!](https://tio.run/##K6gsyfj/v@r/f6XEnPyMRCUA "Pyth ‚Äì Try It Online") Just outputs the input. Requires strings to be in quotes. -1 byte thanks to KarlKastor ]
[Question] [ ## Challenge Given two integers `A` and `B` as input, you must write a program which outputs if `A>B`, `A==B` or `A<B`. The integers will be in any reasonable range supported by your language which includes at least 256 values. Your program can be either a full program or a function, taking input via STDIN or function arguments. ## Outputs If `A>B` output ``` A is greater than B ``` If `A==B` output ``` A is equal to B ``` If `A<B` output ``` A is less than B ``` Where you replace `A` and `B` for their integer values. For example: ``` A B Output -- -- ------ 0 1 0 is less than 1 5 2 5 is greater than 2 20 20 20 is equal to 20 ``` ## Winning The shortest program in bytes wins. ## Leaderboard ``` var QUESTION_ID=55693,OVERRIDE_USER=8478;function answersUrl(e){return"http://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"http://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+)(?=[^\n\d<>](?:<(?:s>[^\n<>]<\/s>\|[^\n<>]+>)[^\n\d<>])<\/h\d>)/,OVERRIDE_REG=/^Override\sheader:\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> ``` [Answer] # Python 2, ~~95~~ ~~94~~ 76 bytes Input must be comma separated. ``` A,B=input();print A,'is',['equal to','greater than','less than'][cmp(A,B)],B ``` [Answer] # CJam, 47 ``` q~_~-g"is equal greater less to than"N/Sf/f=S* ``` [Try it online](http://cjam.aditsu.net/#code=q~_~-g%22is%0Aequal%20greater%20less%0Ato%20than%22N%2FSf%2Ff%3DS&input=%5B3%202%5D) Explanation: ``` q~ read and evaluate the input (array of 2 numbers) _ duplicate the array ~- dump one array on the stack and subtract the numbers g get signum (-1 for <, 0 for ==, 1 for >) "…" push that string N/ split into lines Sf/ split each line by space f= get the corresponding word (for the signum) from each line * join the array of 2 numbers by the array of words it effectively inserts the words between the numbers S* join everything with spaces ``` [Answer] # [Labyrinth](https://github.com/mbuettner/labyrinth), ~~180~~ ~~152~~ 149 bytes ``` < ?01.23.511.501.23};,!:? : = ;3.114.101.97.116.101.114.32.116.104.97.110.32.{!@ -"" ; ;8.101.115:..""""""""""""^ 1 .113.117.97.108.32.116.111.32.{!@ ``` Edit: Managed to shave off 3 bytes by reusing `10` between `101`, `103` and `108` (the character codes of `e`, `g` and `l`). The explanation below does not reflect this, but it's not a substantial change. ## Explanation There isn't much we can do in the way of saving bytes for printing the strings, that's just going to be long linear sections. So the main challenge in golfing is to avoid large amounts of unnecessary whitespace. That means we want the linear parts to "radiate out" from the left-most column. We can also gain some more savings by reusing the code that prints `than B`. So let's look at the control flow here: The program starts on a grid rotation command `<`. This shifts the current row cyclically to the left with the IP on it, so we get this: ``` < ?.23.511.501.23};,!:? : = ;103.114.101.97.116.101.114.32.116.104.97.110.32.{!@ -"" 1 ;108.101.115:..""""""""""""^ 0 1.113.117.97.108.32.116.111.32.{!@ ``` Now the IP is on an isolated cell, so it executes the same command again and again while the `<` travels further to the left until... ``` < ?.23.511.501.23};,!:? : = ;103.114.101.97.116.101.114.32.116.104.97.110.32.{!@ -"" 1 ;108.101.115:..""""""""""""^ 0 1.113.117.97.108.32.116.111.32.{!@ ``` At this point, the IP has somewhere to go and executes the first linear section (the second row) from right to left. What it does is read `A`, copy, print. Consume the delimiting character between the numbers, print `is` (and spaces). Then read `B`, copy it and subtract `A` from it at the `-`. At this point we hit first "fork in the road". If the difference yielded `0`, the IP keeps moving straight ahead towards the bottom branch. That branch simply prints `equal to` and then `B`. Otherwise, the IP takes a left towards the two no-ops `""`. Then there's another fork. If the difference was negative, the IP takes another left towards the long upper branch. That branch simply prints `greater than` and then `B`. If the difference was positive, the IP takes a right onto the lower branch, which prints `less`. Now we want to reuse the `than` from the other branch. But at the same time we don't want to connect the two branches later on, because we'd need a whole bunch of unnecessary spaces. Instead we use a few no-ops to align the lower branch with where the `than` begins on the upper branch and then start manipulating the source again with `^`: ``` < ?.23.511.501.23};,!:? : . = ;103.114.101.97.116.101.114 32.116.104.97.110.32.{!@ -"" ^ 1 ;108.101.115:.."""""""""""" 0 2 1.113.117.97.108.32.116.111.3 .{!@ ``` Again, this is isolates the IP, so `^` is executed again and we get ``` < ?.23.511.501.23};,!:? . : = ;103.114.101.97.116.101.114^32.116.104.97.110.32.{!@ -"" 1 ;108.101.115:..""""""""""""2 0 1.113.117.97.108.32.116.111.3 .{!@ ``` Now the IP can continue moving to the right and print `than` and `B` as required. [Answer] # JavaScript (ES6), 66 bytes ``` (a,b)=>a+` is ${a<b?"less than":a>b?"greater than":"equal to"} `+b ``` Defines an anonymous function. Test by adding `f=` before it, and call it like `alert(f(4, 5))` No savings to be had from the repetitive "than", unfortunately. [Answer] # Java, ~~114~~ 113 Bytes or ~~74 72~~ 67 if we used lambda notation Thanks to Kevin Cruijssen for currying based solution: `a->b->a+" is "+(a==b?"equal to ":(a>b?"greater":"less")+" than ")+b` Old pre lambda solution ``` public void c(int a,int b){System.out.print(a+" is "+(a==b?"equal to ":(a>b?"greater":"less")+" than ")+b);} ``` as user h.j.k meantion in comment, if we used lambda we can do significantly down to 74 bytes. ``` (a,b)->a+" is "+(a==b?"equal to ":(a>b?"greater":"less")+" than ")+b; ``` [Answer] # R, 80 bytes ``` function(A,B)cat(A,"is",c("less than","equal to","greater than")[2+sign(A-B)],B) ``` [Answer] # Pyth, 52 49 bytes ``` jdm@cd)._-FQcj" is equal greater less to than "Qb ``` [Answer] # Julia, ~~69~~ 66 bytes ``` f(A,B)="$A is $(A>B?"greater than":A<B?"less than":"equal to") $B" ``` This uses string interpolation to embed `A`, `B`, and the ternary inside a single string. Saved 3 bytes thanks to Glen O. [Answer] # Perl, ~~64~~ 63 bytes ``` #!/usr/bin/perl -p s/ /" is ".("equal to ",greaterx,lessx)[$`<=>$']/e;s/x/ than / ``` 62 bytes + 1 byte for `-p`. Takes input from STDIN, with the two numbers separated by a single space: ``` $ echo 1 2 \| ./cmp 1 is less than 2 $ echo 42 -17 \| ./cmp 42 is greater than -17 $ echo 123456789 123456789 \| ./cmp 123456789 is equal to 123456789 ``` ## How it works: The `<=>` operator returns -1, 0, or 1 depending on whether the first operand is less than, equal to, or greater than the second. Conveniently, Perl allows negative subscripts with arrays and slices, where the last element is at position -1, the second-to-last element is at position -2, and so on. In the code ``` ("equal to ",greaterx,lessx)[$`<=>$'] ``` we use the return value of `<=>` as the subscript in a list slice to get the corresponding string, where `$`` is the first number and `$'` is the second. To avoid repeating `than`, `x` is used as a placeholder and replaced in a second substitution at the end. --- # Alternative solution, 63 bytes ``` #!/usr/bin/perl -p @a=(equal,greater,than,to,less);s/ / is @a[$i=$`<=>$',!$i+2] / ``` 62 bytes + 1 byte for `-p`. Takes space-separated input from STDIN just like the first solution. ## How it works: This solution also uses a slice, but takes advantage of the fact that unlike list slices, array slices can be interpolated into strings (and the RHS of substitutions). This lets us drop the `/e` modifier and the quotes in the substitution operator. The real trick is in the slice subscript: ``` @a[$i=$`<=>$',!$i+2] ``` For the different values of `<=>`, this gives: ``` $i !$i+2 $a[$i] $a[!$i+2] ---------------------------- -1 2 less than 0 3 equal to 1 2 greater than ``` When an array or array slice is interpolated into a string, the elements are automatically joined by `$"` (by default, a single space). [Answer] # [Mouse](https://en.wikipedia.org/wiki/Mouse_(programming_language)), 79 bytes ``` ?A:?B:A.!" is "A.B.<["less than"]A.B.>["greater than"]A.B.=["equal to"]" "B.!$ ``` When strings are encountered they're immediately written to STDOUT rather than being put on the stack. The stack can contain only integers. Ungolfed: ``` ? A: ~ Read an integer A from STDIN ? B: ~ Read an integer B from STDIN A. ! ~ Write A to STDOUT " is " A. B. < [ "less than" ] ~ If A < B A. B. > [ "greater than" ] ~ If A > B A. B. = [ "equal to" ] ~ If A == B " " B. ! ~ Write B to STDOUT $ ~ End of program ``` [Answer] # GolfScript, 61 bytes ``` \.@.@="equal to "{.@.@>"greater""less"if" than "+}if" is "\+@ ``` Expects 2 integers on the stack. [Try it online](http://golfscript.apphb.com/?c=OzIgMwoKXC5ALkA9ImVxdWFsIHRvICJ7LkAuQD4iZ3JlYXRlciIibGVzcyJpZiIgdGhhbiAiK31pZiIgaXMgIlwrQA%3D%3D). How it works: * `\.@.@` - A and B are already on the stack, and this code piece makes the stack look like this: `ABBA`. `\` swaps the two top items on the stack, `.` duplicates the top item, and `@` rotates the 3 top items (`1 2 3` -> `2 3 1`). * Then, three items are pushed to the stack: the `=` sign, `"equal to "`, and the block between `{}`. The `if` statement does this: if the first argument evaluates to true, it executes the first code block (the second argument), otherwise, the second code block (the third argument). So if A and B are equal, it will push "equal to " on the stack. If they are not equal, it will execute the code between the block. Note that `=` pops the two top items from the stack, so now the stack looks like `AB`. * Inside the block, you first see `.@.@`. Before these commands, the stack looks like `AB`, and after, the stack looks like `BAAB`. The commands are similar as the ones mentioned above. * Then, there's another `if` statement. This time, it checks whether A > B, and if true, it pushes "greater" on the stack. Else, it pushes "less" on the stack. After pushing one of these two, it will push " than " on the stack and concatenate it with the previous pushed string. `>` also pops the two top items of the stack, so now the stack looks like `BA"string"`. * The next three commands are: `" is "\+`. `" is "` pushes that string on the stack (stack looks like `BA"string"" is "`), `\` swaps the two top items (stack looks like `BA" is ""string"`), and `+` concatenates the two top items (stack looks like `BA" is string"`). * The last command, `@`, rotates the three stack items, so the stack now looks like: `A" is string"B`. GolfScript automatically prints the stack values on STDOUT once the program terminates, so then you get the desired output. [Answer] # MATLAB, 105 bytes ``` x=input('');y=input('');t={'less than','greater than','equal to'}; sprintf('%i is %s %i',x,t{(x>=y)+(x==y)+1},y) ``` Added a line break before sprintf, to ease readability. It works both with and without this line break, so it's not included in the byte count. Must hit enter between the two input numbers. [Answer] # Bash, 76 ``` a=(less\ than equal\ to greater\ than) echo $1 is ${a[($1>$2)-($1<$2)+1]} $2 ``` [Answer] # Fortran, 129 Fortran arithmetic if is perfect for this challenge Test: [ideone](http://ideone.com/LPdsJF) ``` read(,)i,j if(i-j)1,2,3 1 print,i," is less than",j stop 2 print,j," is equal to",j stop 3 print,i," is greater than",j end ``` [Answer] # Lua, 118 bytes I don't see enough Lua answers here so... ``` function f(a,b)print(a>b and a.." is greater than "..b or a==b and a.." is equal to "..b or a.." is less than "..b)end ``` Ungolfed: ``` function f(a,b) print(a>b and a.." is greater than "..b or a==b and a.." is equal to "..b or a.." is less than "..b) end ``` [Answer] # Bash, 94 86 bytes (saved eight bytes thanks to Digital Trauma) ``` p=equal;q=than;(($1>$2))&&p=greater&&[ ]\|\|(($1<$2))&&p=less\|\|q=to;echo $1 is $p $q $2 ``` Test (on Linux): ``` echo 'p=equal;q=than;(($1>$2))&&p=greater&&[ ]\|\|(($1<$2))&&p=less\|\|q=to;echo $1 is $p $q $2' > cmp.sh chmod +x cmp.sh ./cmp.sh 10 12 10 is less than 12 ``` The use of `[ ]` after `p=greater` is to prevent `\|\|` operator from being evaluated before `=` in the expression `...&&p=greater\|\|(($1<$2))...` (the operator precedence!). The alternative would be using brackets around `(($1>$2))&&p=greater` and `(($1<$2))&&p=less` , but brackets make inner scope for variables, so `p` would be left unaltered. [Answer] # IA-32 machine code + linux, 107 bytes Hexdump of the code: ``` 60 89 e5 89 d0 e8 51 00 00 00 4c c6 04 24 20 38 d1 74 20 68 74 68 61 6e 4c c6 04 24 20 72 0d 68 61 74 65 72 68 20 67 72 65 44 eb 11 68 6c 65 73 73 eb 0a 68 6c 20 74 6f 68 65 71 75 61 68 20 69 73 20 88 c8 e8 12 00 00 00 89 ea 29 e2 89 e1 31 db 43 8d 43 03 cd 80 89 ec 61 c3 5b d4 0a 4c 04 30 88 04 24 c1 e8 08 75 f3 ff e3 ``` Because of hardware limitations, the code works with numbers in the range 0...255. Source code (can be assembled with gcc): ``` .globl print_it .text .align 16 print_it: pushal; mov %esp, %ebp; // save esp (stack pointer) mov %edx, %eax; // put second number in al call prepend; // convert al to string dec %esp; // write ... movb $' ', (%esp); // ... a space cmp %dl, %cl; // compare the numbers je equal; // if equal, goto there push $0x6e616874; // write "than" dec %esp; // write ... movb $' ', (%esp); // ... a space jb less; // if below, goto there greater: push $0x72657461; // write "ater" push $0x65726720; // write " gre" inc %esp; // remove a space jmp finish; // bypass the code for "less than" less: push $0x7373656c; // write "less" jmp finish; // bypass the code for "equal" equal: push $0x6f74206c; // write "l to" push $0x61757165; // write "equa" finish: push $0x20736920; // write " is " mov %cl, %al; // put first number in al call prepend; // convert al to string mov %ebp, %edx; // calculate the length ... sub %esp, %edx; // ... of the output message mov %esp, %ecx; // address of the message xor %ebx, %ebx; // set ebx to ... inc %ebx; // ... 1 (i.e. stdout) lea 3(%ebx), %eax; // set eax=4 (syscall "write") int $0x80; // do the system call mov %ebp, %esp; // restore the stack pointer popal; // restore other registers ret; // return prepend: // writes al converted to string pop %ebx; // remove return address from the stack appendloop: aam; // calculate a digit in al, rest in ah dec %esp; add $'0', %al; // convert the digit to ASCII mov %al, (%esp);// write the digit shr $8, %eax; // replace al by ah; check if zero jnz appendloop; // nonzero? repeat jmp %ebx; // return ``` --- This is some serious abuse of the stack! The code builds the output message on the stack, from the end to the beginning. To write 4 bytes, it uses a single `push` instruction. To write 1 byte, it uses two instructions: ``` dec %esp mov %al, (%esp); ``` By luck, most of the fragments to write are 4 bytes. One of them ("gre" in "greater") is 3 bytes; it's handled by pushing 4 bytes and removing one afterwards: ``` inc %esp ``` --- The routine that writes numbers in decimal form uses the `aam` instruction to divide `ax` by `10` repeatedly. It's advantageous that it calculates the digits from right to left! --- Since there are two numbers to write, the code uses a subroutine, which is called twice. However, because the subroutine writes the results on the stack, it uses a register to hold the return address. --- C code that calls the machine code above: ``` include <stdio.h> void print_it(int, int) __attribute__((fastcall)); int main() { print_it(90, 102); puts(""); print_it(78, 0); puts(""); print_it(222, 222); puts(""); return 0; } ``` Output: ``` 90 is less than 102 78 is greater than 0 222 is equal to 222 ``` [Answer] # [Fourier](http://esolangs.org/wiki/Fourier), ~~147~~ 74 bytes *Non-competing because string printing is newer than this challenge* ``` I~AoI~B` is `<A{1}{`greater than`}A<B{1}{`less than`}A{B}{`equal to`}` `Bo ``` [Try it on FourIDE!](https://beta-decay.github.io/editor/?code=SX5Bb0l-QmAgaXMgYDxBezF9e2BncmVhdGVyIHRoYW5gfUE8QnsxfXtgbGVzcyB0aGFuYH1Be0J9e2BlcXVhbCB0b2B9YCBgQm8) Dunno why I didn't allow printing before... It makes the code readable and is great for golfing [Answer] # [ShortScript](http://esolangs.org/wiki/ShortScript), 98 bytes ``` ←Α ←Β ↑Γαis ↔α>β→γgreater thanβ ↔α<β→γless thanβ ↔α\|β→γequal toβ ``` [Answer] ## C, 155 136 127 83 bytes ``` f(a,b){printf("%d is %s %d\n",a,a>b?"greater than":a<b?"less than":"equal to",b);} ``` [Answer] # Haskell, 87 bytes One byte shorter than Otomo's approach. ``` a?b=show a++" is "++["less than ","equal to ","greater than "]!!(1+signum(a-b))++show b ``` [Answer] # Python 2, 78 bytes I love how `cmp()` is really useful, but it was [removed in Python 3](https://docs.python.org/3.0/whatsnew/3.0.html#ordering-comparisons). Using an anonymous function: ``` lambda a,b:`a`+' is '+['equal to ','greater than ','less than '][cmp(a,b)]+`b` ``` Not using a function (79 bytes): ``` a,b=input();print a,'is %s'%['equal to','greater than','less than'][cmp(a,b)],b ``` [Answer] # JavaScript, ~~151 104 100 95~~ 92 bytes ``` a+=prompt() b+=prompt() alert(a+" is "+(a>b?"greater than ":a<b?"lesser than ":"equal to ")+b) ``` I managed to shorten with help of edc65 [Answer] # C# 6, ~~113~~ ~~103~~ ~~100~~ 95 bytes ``` void C(int a,int b){System.Console.Write($"{a} is {a-b:greater than;less than;equal to} {b}");} ``` Thanks to edc65 for saving 13 bytes and to cell001uk for saving 5 bytes using C# 6's [interpolated strings](https://msdn.microsoft.com/en-us/library/Dn961160.aspx)! [Answer] # [Rust](https://www.rust-lang.org/), 271 bytes ``` use std::cmp::Ordering::;fn main(){let v:Vec<String>=std::env::args().collect();let a:u8=v[1].parse().unwrap();let b:u8=v[2].parse().unwrap();print!("{} is ",a);print!("{}", match a.cmp(&b) {Less=>"less than",Equal=>"equal to",Greater=>"greater than"});print!(" {}",b);} ``` ## Pretty printed version: ``` use std::cmp::Ordering::; fn main() { let v:Vec<String> = std::env::args().collect(); let a:u8 = v[1].parse().unwrap(); let b:u8 = v[2].parse().unwrap(); print!("{} is ", a); print!("{}", match a.cmp(&b) { Less => "less than", Equal => "equal to", Greater => "greater than" }); print!(" {}", b); } ``` [Answer] # [rs](https://github.com/kirbyfan64/rs), 105 bytes ``` (\d+) (\d+)/\1 is (_)^^(\1) (_)^^(\2) \2 (_+) \1_+/ less than (_+) \1 / equal to _+ _+/greater than ``` The trailing and preceding whitespace is very important! [Live demo and all test cases.](http://kirbyfan64.github.io/rs/index.html?script=%24%24x%3D%28_%29%5E%5E%28%0A%28%5Cd%2B%29%20%28%5Cd%2B%29%2F%5C1%20is%20%24x%5C1%29%20%24x%5C2%29%20%5C2%0A%C2%A0%28_%2B%29%20%5C1_%2B%2F%20less%20than%0A%C2%A0%28_%2B%29%20%5C1%20%2F%20equal%20to%C2%A0%0A_%2B%20_%2B%2Fgreater%20than&input=2%201%0A2%202%0A1%202) [Answer] # Pyth, ~~57~~ ~~55~~ 53 bytes ``` AQjd[G"is"@c"equal to greater than less than"b._-GHH) ``` This basically does: ``` ["less than", "greater than", "equal to"][sign_of(A-B)] ``` Saved 2 bytes thanks to @AlexA.'s suggestion of using `A` instead of `J` and `K` and another 2 bytes by replacing the whole addition mess with a simpler subtraction. [Live demo and test cases.](https://pyth.herokuapp.com/?code=AQjd%5BG%22is%22%40c%22equal+to%0Agreater+than%0Aless+than%22b._-GHH)&input=%5B2%2C1%5D&test_suite=1&test_suite_input=%5B2%2C1%5D%0A%5B2%2C2%5D%0A%5B1%2C2%5D&debug=1) ## 55-byte version ``` AQjd[G"is"@c"less than greater than equal to"b+gGHqGHH) ``` [Live demo and test cases.](https://pyth.herokuapp.com/?code=AQjd%5BG%22is%22%40c%22less+than%0Agreater+than%0Aequal+to%22b%2BgGHqGHH)&input=%5B2%2C1%5D&test_suite=1&test_suite_input=%5B2%2C1%5D%0A%5B2%2C2%5D%0A%5B1%2C2%5D&debug=1) ## 57-byte version: ``` jd[JhQ"is"@c"less than greater than equal to"b+gJKeQqJKK) ``` [Live demo and test cases.](https://pyth.herokuapp.com/?code=jd%5BJhQ%22is%22%40c%22less+than%0Agreater+than%0Aequal+to%22b%2BgJKeQqJKK)&input=%5B2%2C1%5D&test_suite=1&test_suite_input=%5B2%2C1%5D%0A%5B2%2C2%5D%0A%5B1%2C2%5D&debug=1) [Answer] # O, 67 bytes ``` jJ" is ""greater than""less than""equal to"JjK-.e\1<+{@}d;;' K++++p ``` [Live demo.](http://o-lang.herokuapp.com/link/code=jJ%22+is+%22%22greater+than%22%22less+than%22%22equal+to%22JjK-.e%5C1%3C%2B%7B%40%7Dd%3B%3B%27+K%2B%2B%2B%2Bp&input=2%0A2) [Answer] # SWI-Prolog, 94 bytes ``` a(A,B):-(((A>B,C=greater;A<B,C=less),D=than);C=equal,D=to),writef("%t is %t %t %t",[A,C,D,B]). ``` [Answer] # Swift, 105 92 byte ``` func c(a:Int, b:Int){println("A is",(a==b ?"equal to":(a<b ?"less":"greater")," than"),"B")} ``` even shorter with Swift 2.0 (103 90 byte) ``` func c(a:Int, b:Int){print("A is",(a==b ?"equal to":(a<b ?"less":"greater")," than"),"B")} ``` ]
[Question] [ Inspired by [this comment...](https://codegolf.stackexchange.com/questions/61115/make-your-language-unusable#comment147104_61115) Thanks to users [Step Hen](https://codegolf.stackexchange.com/users/65836/step-hen), [Wheat-Wizard](https://codegolf.stackexchange.com/users/56656/wheat-wizard), and [Dennis](https://codegolf.stackexchange.com/users/12012/dennis) for helping my solidify the specification of this challenge before posting it! This is the Robber's thread! For the Cops' thread, go [here](https://codegolf.stackexchange.com/q/133174/31716) --- In [this challenge](https://codegolf.stackexchange.com/q/61115/31716), you are tasked with running some code that makes it so that your language no longer satisfies our criteria of being a programming language. In that challenge, that means making it so that the language can no longer... * Take numerical input and output * Add two numbers together * Test if a certain number is a prime or not. This is a [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'") challenge, where there are two different challenges with two different objectives: The Cops will try to write some code that makes the language mostly unusable, and the robbers will try to find the hidden workaround that allows the cops to recover their language. The cops will write two snippets of code: 1. One that makes their language mostly unusable, e.g. by removing built in functions for taking input/output and numerical operations. This code is not allowed to crash or exit. It should be possible to add code to the end of this snippet, and that code will get evaluated. And 2. A snippet of code that takes two numbers as input, adds them together, and outputs their sum. This snippet must still correctly function even after running the first snippet. When the two snippets are combined together, they must form a full program that adds two numbers, or define a function that adds two numbers. This snippet will probably rely upon obscure behavior, and be hard to find. The cops will also choose any [standard method of input and output](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods?answertab=votes#tab-top). However, they must reveal exactly which format (input and output) they are using. For you to crack their answer, you must follow the same input/output format, or your crack does not count. A cops answer will always reveal * The first snippet (obviously not the second). * Language (including minor version, since most submissions will probably rely on strange edge-cases) * IO format, including whether it's a function or full program. Robbers must use the same format to be a valid crack. * Any strange edge cases required for their answer to work. For example, only runs on linux, or requires an Internet connection. As a robber, you must look at one of the cops submissions, and attempt to crack it. You may crack it by writing any valid snippet that could work as snippet 2 (adding two numbers together after the language is made mostly unusable). This does not have to be the same snippet that the cop originally wrote. Once you have an answer cracked, post your code as an answer on this thread, and post a link to your answer as a comment on the cop's answer. Then, that post will be edited to indicate is has been cracked. Here's an example. For the first snippet, you might see the following python 3 program as a cops answer: > > # Python 3 > > > > ``` > print=None > > ``` > > Takes input from STDIN and output to STDOUT > > > A valid second snippet could be ``` import sys a,b=int(input()),int(input()) sys.stdout.write(a+b) ``` This is valid because it will take two numbers as input, and output their sum even if you join the two snippets together, e.g. ``` print=None import sys a,b=int(input()),int(input()) sys.stdout.write(a+b) ``` This is a valid crack to their answer. If a cop's answer remains uncracked for one whole week, they may edit in their second snippet, and indicate that their answer is now safe. Once it is edited to be safe, you may no longer attempt to crack it. If they do not edit it as safe, you may continue to try to crack it until they do. The winner of the robber's thread is the user who has cracked the most answers, with the tie-breaker being the time they reached N cracks. (so if two different users each have 5 cracks for example, the user who posted their 5th crack first is the winner) After sufficient time has passed, I will accept the winner's answer with the most votes. Have fun! # Rule clarifications * The first snippet must run correctly without taking any input. It may output whatever you like, and this output will be ignored. As long as after the snippet is done, the second snippet runs correctly. * The second snippet must actually be executed for your answer to be valid. This means an answer like ``` import sys sys.exit() ``` is not valid because it doesn't break the language. It simply quits. * After being safe, your score is the byte count of both snippets. * This goes back to Please reveal any strange edge cases required for your answer to work... Your submission must contain enough information before being revealed to be reproducible after being revealed. This means that if your answer becomes safe, and then you edit in: Here's my answer. Oh ya, BTW this only works if you run it on Solaris, jokes on you! your answer is invalid and will be deleted and not considered eligible for winning. * The second snippet is allowed to crash after outputting the sum. As long as the output is still correct (for example, if you choose to output to STDERR, and then you get a bunch of crash information, this is invalid) # Leaderboard Here is a list of every user with at least one crack, ordered by score and then name (alphabetical). If you submit a crack, please update your score accordingly. ``` #User #Score Ilmari Karonen 8 Dennis 5 Olivier Grégoire 4 Sisyphus 3 Veedrac 3 Arnold Palmer 2 Bruce Forte 2 DJMcMayhem 2 Dom Hastings 2 ppperry 2 1bluston 1 2012rcampion 1 Ben 1 BlackCap 1 Christian Sievers 1 Cody Gray 1 HyperNeutrino 1 Joshua 1 Kaz 1 Mark 1 Mayube 1 Xnor 1 zbw 1 ``` [Answer] ## [C (GCC/Linux) by Sisyphus](https://codegolf.stackexchange.com/a/133324/39174) This snippet closes the provided function and starts a new one (classic code injection), which itself redefines `close` so that instead of closing the fd, runs our desired code. ``` } int close(int x) { int a, b; scanf("%d %d", &a, &b); printf("%d\n", a + b); exit(0); ``` [Answer] # Python, Wheat Wizard's solution [here](https://codegolf.stackexchange.com/a/133198/68942) ``` import sys c="".join(open(__file__).read().split('\n')[4:]) if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1) f=lambda\ :[] # my code starts here sys.setrecursionlimit(1000) print(int(input())+int(input())) ``` I mean, you can just set the recursion limit back, and nothing bad happens... [Works on TIO](https://tio.run/##dY1BCsIwFET3OUXJwuajhipaodCTtCXGNMFf2iQk6aIbr14rbty4GIaBxxu/pKez53XFybuQsrhEompK@eDQMue1ZUIYHLUQwIOWPQMe/YiJ5a3NoblUHRA0WdSJKTh@Ks92wA68ajp5V73BYXI2pFcOLtDvC0WbqWq74hsftJpDRGdHnDbtCYipRzk9etmSzUH@YEVRAPEBbWLf@DkxgP3vgHW9lqS8vQE) # Note This is my first ever CnR submission, so if this breaks any rules, please tell me and I'll delete this. [Answer] ## Haskell by Ben ``` import Prelude(getLine,print) a=a []++s=s (a:as)++s=a:(as++s) r""="" r(c:s)=(r s)++[c] t(_:r)=r ts l=l:ts(t l) x[_](v:_)=v x(_:r)(_:s)=x r s d(a:_:_:_:_:_:_:_:_:_:r)=a:d r (a:_)!!""=a l!!(n:m)=d(x['0'..n](ts l))!!m a+b=[[0..]!!a..]!!b a-b=let n=[0..]!!a;m=[0..]!!b in case [n..m] of [] -> x[m..n][0..] l -> -(x l [0..]) add('-':x)('-':y)= -(r x+r y) add('-':x)y=r y-r x add x('-':y)=r x-r y add x y=x+y main=do a<-getLine;b<-getLine;print(add a b) ``` I still have literal numbers and chars (I use `0`, `'0'` and `'-'`), and `[a..]` and `[a..b]` which are very useful. And I have unary `-`, but I could do without. I recreate `++` to implement `r` (`reverse`) and define `t` and `ts` which are `tail` and `tails`. `x a b` returns the `n`th element of `b`, where `n` is the length of `a` minus one. `x` could usually be defined as `snd.last.zip`. The function `d` takes a list and returns a list with the elements from those positions that are multiples of ten. `l!!s` returns the `n`th element of `l`, where `s` is the reversed string representation of `n`. `+` returns as integer the sum of two natural numbers given as reversed strings, likewise `-` for the difference. `add` returns as integer the sum of two possibly negative integers given as strings. I wonder if this is somewhat similar to what Ben had in mind. [Answer] # [C (gcc) by Conor O'Brien](https://codegolf.stackexchange.com/a/133211/12012) ``` void post_main() __attribute__ ((destructor)); void post_main() { int a, b; char sum[11]; void stdin = fdopen(0, "r"); fscanf(stdin, "%u %u", &a, &b); sprintf(sum, "%u", a + b); write(1, sum, strlen(sum)); } ``` [Try it online!](https://tio.run/##ZVHLboMwEDzDV6xSJTItTUrbW9Rb/qKqkDFLQAKM/EgaRfl2ul4gOfQ0sw/PDoN6PSo1jk8lVk2PcBBVctJNCZUIkOzjgxhM07sqodGdDd6pCSzBEZ2qpXn0qwXRGG2Y6PDMoCxDpVptMZC5cTaZ45qU7IysrwfspgP28dwq2Qc1i67wgeAvqnbBYbYxGeIWzuRE2Mm21WppDHey7ATdi3V89m7zbBr2R3b6yTYmMUUB1pVNv2fayaYXyTXe7S7aG1C6RDhqtFCjwe12W2ON8S3mcAdtXT49gDyXzpmm8A7zHIQo0TrjlaPcKP1/@/E1jsI5mUKxj6PwmWB9951lP1Ty9jO7gi@oymBYvKWwMqsgFlWcneAF6q49rP0qhQ2pbQraiOz0iwVJ8pyGEl6AZ5yCyFLgIblsSZx48Hkbx@wdPj7/AA "C (gcc) – Try It Online") [Answer] # [Python 2 by Wheat Wizard](https://codegolf.stackexchange.com/a/133229/20260) (fourth iteration) ``` import sys if set("".join(open(__file__).read().split('\n')[4:]))-set(' &)(,.:[]a`cdfijmonrt~'):sys.setrecursionlimit(1) for m in sys.modules:sys.modules[m]=None del sys;f=lambda\ c,d:(`int([]in[])`[:[]in[]]).join([((c)and`dict([((int([]in[])),(int([]in[])))])`[(int([]in[[]])):][(int([]in[[]]))].join([`dict([((int([]in[])),(int([]in[])))])`[(int([]in[]))],`dict([((int([]in[])),c)])`[(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):]])or`int([]in[])`[:[]in[]]).format((int([]in[]))),((d)and`dict([((int([]in[])),(int([]in[])))])`[(int([]in[[]])):][(int([]in[[]]))].join([`dict([((int([]in[])),(int([]in[])))])`[(int([]in[]))],`dict([((int([]in[])),d)])`[(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):]])or`int([]in[])`[:[]in[]]).format((int([]in[]))),`(int([]in[]))`]).rfind(`(int([]in[]))`) ``` [Try it online!](https://tio.run/##zVDLSgMxFN3PVwxdOLkwBhRXkf6CP5CGSUwyeEseQ5IuuvHXx4QKtkWhrnR3z@E8Lmc5lrcYHtcV/RJT6fMxdzj32Ray2dB9xEDiYgOZphmdnSagySpDgObFYSHDLgzAn5gAuG@eob8DMlLGhZLazLj3MaTyPgCrwbQqktWHlDEGh776H6CbY@p9j6FVUx/NwdnMzm7uxfYlBtsZ65rmed465V@N2nV6NIxIDIVwgYELkJydLgGn3zkhGlQw0qAuDZ2JYbxA0OxfTMsAJq4Z8Zn7@8BmHr@36du6b2MExPTTJnVrr8ple/2amP@/kfnbjeQFllWXZgyGXPGwrh8 "Python 2 – Try It Online") No exploits, just a function to add using only characters `' &)(,.:[]a`cdfijmonrt~'`, as intended (actually only `'(),.:[]`acdfijmnort'`). I made no attempt to make it short; I just wrote subexpressions for intermediate values like 0 and the empty string and string-substituted those in. ``` def f(c,d): FALSE = []in[] TRUE = []in[[]] ZERO = int([]in[]) ONE = int(TRUE) EMPTY = `int([]in[])`[:[]in[]] ZERO_STR = `ZERO` ONE_STR = `ONE` ZERO_DICT = dict([(ZERO,ZERO)]) ZERO_DICT_STR = `ZERO_DICT` OPEN_BRACE = ZERO_DICT_STR[ZERO] COLON = ZERO_DICT_STR[ONE:][ONE] CLOSE_BRACE = ZERO_DICT_STR[ONE:][ONE:][ONE:][ONE:][ONE] C_STR = `c` D_STR = `d` FORMAT_STR_C = ''.join([OPEN_BRACE, ZERO_STR, COLON, C_STR, CLOSE_BRACE]) FORMAT_STR_D = ''.join([OPEN_BRACE, ZERO_STR, COLON, D_STR, CLOSE_BRACE]) LENGTH_C_STR = c and FORMAT_STR_C.format(ONE_STR) or EMPTY LENGTH_D_STR = d and FORMAT_STR_D.format(ONE_STR) or EMPTY TOTAL_STR = EMPTY.join([LENGTH_C_STR, LENGTH_D_STR, ZERO_STR]) RESULT = TOTAL_STR.find(ZERO_STR) return RESULT ``` [Try it online!](https://tio.run/##jVLBToNAED3DV8ylYYmkBxMvTTwgbNWEsg3QgxICDRSliUuDePDrcYayFFubeBl2Hm/evNmdw3f7Xsvbrit2JZQstwpzoWtL2ws53EOcVDJOdC0KNmMaJwi88kAgUMmWHTmmrgmfDxDREeCrdfSCUDahZfHieBpE0jAKiELnrNdQCB4zfSC5z06EWFHlKMQIsiiY1HYkTKV6gMrFmvvpQ2A75O0XNaYMXTjCE/7FT@y@SCgSwxMhvyIy8i5jgu0dZSrH4VyVFORsKYKV3YukDoKGMd/XlWTxybEF6oYs6F3iZ8hOjugKJlLuv6Xcv6R0zeP@Y/SUKuM5bGUBU6/zsm4@ti0bnsqEuoH@pcdaNWdxXuter8UdE5HtDZU9NgwxNWTBtMVpKLqEgIcbj7ZkFJqXlSyY4tBwza79aiQcqR2agQoXFpqtfNuxO9p8wvZnmHZocIPBmH3CDWC4x2DAjFXW3iopmmb3Aw "Python 2 – Try It Online") The core idea is that string format `'{0:5}'.format('1')` pads the number zero to a length of `5` like `'1 '`. By concatenation two such strings using `''.join`, the sum of their length is the sum of the input numbers. Then, we tack on a `0` to the end and call `.find()` to the final position, which is the sum. The string `'{0:5}'` to format is produced by extracting the `{:}` characters from string reprs of dictionaries, created with `dict`. The string repr of each successive summand is placed where the 5 would be. I wanted to use a dict like `{0:5}` itself, but its repr includes a space that messed it up. Inputs of 0 mess up the process because the string sub has a minimum length of 1. We have those with an `and/or` to give the empty string in this case. [Answer] # [Haskell, by Laikoni](https://codegolf.stackexchange.com/a/133239/17061) ``` main=main-- & ((+) <$> readLn <> readLn >>= print) i&o=o ``` [Answer] # [x86 16-bit real-mode assembly, by Joshua](https://codegolf.stackexchange.com/a/133212/58518) ``` int 0x3 ; <--- this is the "robber" portion ; -- begin code to print numbers in real-mode asm using ROM BIOS video interrupts -- add dx, cx ; add input values together mov ax, dx ; move result into AX push WORD 0xB800 pop ds ; DS == starting address of text-mode video buffer xor cx, cx ; digit counter xor di, di ; position counter mov bx, 0xA ; divisor test ax, ax ; is number negative? jns .GetDigits neg ax ; convert negative number to positive mov WORD ds:[di], 0x4F2D ; output leading negative sign, in white-on-red add di, 2 ; increment position counter .GetDigits: xor dx, dx div bx ; divide DX:AX by 10 (AX == quotient, DX == remainder) push dx ; push digit onto stack inc cx ; increment digit counter test ax, ax jnz .GetDigits ; keep looping until we've got 'em all .PrintDigits: pop dx ; get digit off of stack dec cx ; decrement digit counter mov dh, 0x4F ; high byte: color attribute (white-on-red) add dl, 0x30 ; low byte: convert to ASCII mov WORD ds:[di], dx ; output digit add di, 2 ; increment position counter test cx, cx jnz .PrintDigits ; keep looping until we've printed 'em all cli hlt ``` [![screenshot of Debug dump of code, along with output in upper-left corner](https://i.stack.imgur.com/Nt0Tz.png)](https://i.stack.imgur.com/Nt0Tz.png) Explanation: The "breakage" introduced by Joshua's code is the setting of the trap flag (TF), which puts the CPU into single-step mode. This means that only a single instruction will be executed at a time, before the CPU stops (traps) with a type-1 interrupt. This is what allows debuggers to implement single-stepping of code—quite handy there, but a real PITA if you want to run the code outside the context of a debugger! It is the following section of code that turns on the trap flag: ``` pushf ; push the FLAGS register onto the top of the stack mov bp, sp ; load the pointer to the top of the stack into BP or word [bp], 256 ; bitwise-OR the WORD at the top of the stack (the copy of FLAGS) ; with 0x100, which turns on bit 8 (TF) popf ; pop the modified flags back off the stack into FLAGS ``` The implementation of the trap flag means that we get a chance to execute exactly one instruction before the CPU traps—that is the one that comes immediately after the `POPF` here. So, we need to make this one count. The trick is the `INT 3` instruction, which invokes interrupt number 3. There are two reasons why this works to "unbreak" the code: 1. The trap flag is cleared in interrupt handlers. This is just part of Intel's design, but it was presumably done for basic sanity reasons. Remember that the implementation of the trap flag is that a type-1 interrupt is invoked after execution of each instruction, so if TF wasn't cleared, `INT 1` would itself trigger an interrupt—it would be interrupts all the way down. Also, having interrupts clear TF just makes it easier to debug the code, much like an IDE that automatically steps over calls to library functions. 2. The way interrupts work is essentially the same as a far `CALL`. They invoke the interrupt handler whose address is stored at the corresponding position in the global interrupt vector table. Since this table begins at address `0x0000:0000`, and is stored in a 4-byte `segment:offset` format, calculating the address is as simple as multiplying 4 by the interrupt vector/number. In this case, we invoke interrupt 3, so that would be 4×3=12. …and you'll notice that Joshua thoughtfully set this up for us. Prior to enabling the trap flag, he has the following code: ``` mov di, 12 mov [di], si mov [di + 2], bp ``` which sets `0x0000:000C` (the interrupt handler for `INT 3`) to `BP:SI`. That means whenever `INT 3` is invoked, it pushes the FLAGS register onto the stack, followed by the return address, and then branches to `BP:SI`, which allows us to start executing code again, in a context where the trap flag is turned off. It's all downhill after `INT 3`. All we need to do is add two numbers together and print the result. Except that this isn't as simple in assembly language as it would be in other languages, so this is where the bulk of the code is spent. [Joshua is allowing the robber to specify any I/O mechanism (s)he wants](https://codegolf.stackexchange.com/questions/133174/make-your-language-mostly-unusable-cops-thread?page=1&tab=votes#comment327233_133212), so I'm taking the simplistic approach of assuming that the values are passed in the `DX` and `CX` registers. That is reasonable, since these are not clobbered anywhere by his "prologue" code. The output then is done by storing ASCII bytes directly into video memory. The video buffer starts at `0xB800:0000` on a text-mode CGA, EGA, and/or VGA, so we start printing there. The format is: character in the low byte, and color attribute in the high byte. That means each character is on a 2-byte offset. We just iterate through each of the digits in the number (base-10), converting them to ASCII and printing them one at a time to the screen. Yes, this is a lot of code. There are no library functions to help us in assembly language. This can almost certainly be optimized further, but I got tired of working on it... After the output is displayed, the code is allowed to crash or do whatever, so we just clear interrupts and halt the CPU. [Answer] # [Haskell](https://codegolf.stahckexchange.com/a/133931/43037) by [zbw](https://codegolf.stackexchange.com/users/69259/zbw) ``` {-#OPTIONS_GHC -fth -w#-} module M where import Language.Haskell.TH.Syntax import System.IO.Unsafe a = $( runIO $ TupE[] <$ do x <- readLn :: IO Integer y <- readLn print $ x + y ) ``` Can't run code at run-time? Run it at compile time! This was a lot of fun, I did not know template haskell before this challenge. [Answer] # [Python 2 by TwiNight](https://codegolf.stackexchange.com/a/133210/12012) ``` print input()+input() # ``` [Try it online!](https://tio.run/##LY7disMgFITv8xSWXCShu3LiT@IW@iSlBKvHKqRGYhbap08t9GoY@D5m0mvzS2T7Hh5pWTeSX/nH6@zncKvMeUkY22lyYcZp6uiK2rYdzWkOW9tdfvtrFRwxh3NTNzpa8hVp9prJoTUd9fi04Y654IXCQQBYO/CRc9sDGhAMuWEKODdOK4m9ZdLd0CkABqoHw6Wwo/krnBK8OZV7FJ@fdVJXaQ1xIyGm/9KP3yT1vgtWyfEN "Python 2 – Try It Online") [Answer] # [Python 3](https://docs.python.org/3/), [ppperry](https://codegolf.stackexchange.com/users/46076/ppperry)'s [2nd Challenge](https://codegolf.stackexchange.com/a/133602/69259) Wow, this was fun! I enjoyed solving this. Edit: OK, I fixed it. It seems like the classes were at a different index in the subclass list on TIO than on my computer, so I made it work for both, and added a TIO. ``` import sys for mod in sys.modules.values():mod.__dict__.clear() 1+1 # My code begins here str = "Hello!".__class__ int = (37).__class__ object = str.__base__ def find_subclass(superclass, name): for cls in superclass.__subclasses__(): if cls.__name__ == name: return cls _io_IOBase = find_subclass(object, '_IOBase') # <class '_io._IOBase'> _io_RawIOBase = find_subclass(_io_IOBase, '_RawIOBase') # <class '_io._RawIOBase'> _ioFileIO = find_subclass(_io_RawIOBase, 'FileIO') # <class '_io.FileIO'> stdout = _ioFileIO('stdout', mode='w', opener=lambda name,flags: 1) # FD for stdout is 1 stdin = _ioFileIO('stdin', mode='r', opener=lambda name,flags: 0) # FD for stdin is 0 nums = str(stdin.read(), encoding='utf-8').split() stdout.write(str(int(nums[0]) + int(nums[1])).encode('utf-8') + b'\n') stdout.flush() ``` [Try it online!](https://tio.run/##fZJPb5wwEMXP608xTQ4YhaJFUf9oVXKoqqg5VJFybSPLwLDrytjIhq7202/HhiXdbRSfzHszPz8x0x@GnTW3x6PqeusG8AfPWuugsw0oEz5zuo4aff5H6hE9Tzck5EI0qh6EyGuN0vGUFTcFY9fw4wC1bRAq3CrjYYcOmR8clHD1HbW2766otdbSeyGYMgMZ/PZT@o9oq99YB53aSK6kR1JZgy20yjTCj1Us5X7s0cVrBkZ2mG7YKkSvtY/RF5sopyakF3goXKk2FJIVWoWAsoyQYK0cDqMzwWdMKCseHr9SCoinvEgxxc0gmauSFOZzDV9iCVnK5if7LhKf5H6BXhJfXgzUpZLAF8QXK0LvlcaHR3g95tmjxJ2KQ9hz6Kzf0dAaO4YxLGSeTFqShe3AMtnTzfZo0JVadlUj4x/MWi23fgNFyHv/DcJIZpjyUAQwTec/sDJEm8HuTfD6HEww4q6ZGTs/bQ2Pau5QNjzNAA1tpDLbMhmH9v3nJM19r9VAOzvFyvdODchDIy0kD5yf6@cUbmD5LJ7TNI8c5CcK@VXyyyQLptWj3xH1ePwAH@Ev "Python 3 – Try It Online") [Answer] # [Java 8 by Olivier Grégoire](https://codegolf.stackexchange.com/a/133579) ``` class A { public A() { String[] args = System.lineSeparator().split(","); System.out.print(Integer.parseInt(args[0]) + Integer.parseInt(args[1])); } } ``` [Try it online!](https://tio.run/##lVZhb9s2EP2eX3H2l8iYq64Dhg01is1YW9RFkw5LgaEo8oGmzhZjiRRIyq6W@q8ve5RkWXacpZFhhBZ57@7evTvmRqzFM1OwvklWdyovjPV0g3exMvFblfGfbHPlnDJ6ctbfzoRexn9kwrkJ9Z/nz@nSkLeV0kuynPBC6bCsj8YPQHwwImE72UMYS72N@1ZX3gJ0cuQYVs3GCYPKec6PDaY6ocToc08@VXpFM1oYuzSemuODEzgsS6t89ear5MIHVgLOZ1PSpsbJlU7GtFFZRpUpf7sP8Fepvcp5chjI@9L54JuWxiSUs3Cl5RNsfUqt2Yh51rOH9ew8oVR4Jm/qBNiT0Ufmmn18ZeSK/UMVdW1qcf@ADFWo9@l2S6cfRHAT4ncm5NwSmjPs8orMRlPjxRH4lcLyosyyigprPEvPCeLUnu1CSKYLoTTdPuAEunJeeCVpniGTmi84HJzRdzyh2pkzY3ofcvkVBGXVd1t@5mJMn2YfaWEV6ySrYNiGsjYKBUPYUSO9L9ckRpAT6uSoKxfd1q4EvSLNm1alX368ntxzVSsBJEjhuLZBK7XWRDv1XQgtlmzJ5TvAw41o1JkQ/f5xzdaqhKko59kuZJmyXO0rHe2XVGDZB6A2XtLwFjZjKOxS5ByNJr1DakER/ugYzKDafyufRkPHfjg6yWnK1Rg8CX9e62SnvjFp9B/Kat1xeb59OwK3LJIT6ABvNBj2UadysXgMaflgmGthlSldPSCWih1qI7MyCXTAiPU6vo8dOMI5ONCSzYIO5@geW6NdseUeRzju3FFokgYBjb0xdnWAUcvvQBjdvIqGl5j2g@FB6bZn91f/JxsLCOurqZTo8lb4tOLqUDWPRBEmQA3TNTKCCkm9C8qYna8xz1JTLlNPYm5KdAXGtDEDejl6WrhvvrLcBSnz5AlBXpSpCJ8BZk/cp2znd7t71VwYsdKxzIwLndFOLKWL0reH0Mq3vWsttFFj13sZjeIMi/pNNJzC6VYKL9NoP0t41I3iMPwpnK87huppPaY5yJq1PYDb1yuRqX8Y/A0Oo0VzHg8Ol3dZPjlS3DGbWavZ3WjYUh09RfWxS@PfmlInHcXIpasGcnltQveHTmuSaFKQVrg0PoTrs9EhNLXk1vNZ@G7PmusZ3BhoI2XLg/DqHe6cl0DmcG2Khjia4uL2KX62EpIG2dhSemNj1BI6RMC6zMM/Glh211Z8t7MPkbTG024I7y8Gu3QYoS37mdJ8xYWwAvgg0xWZ8tFwvNNZewzKjwsA@GgGf6hRDBPH@BEFPFwiI/qBTu@9uB7VYODh7u5fU1Pu7p69Dq5R/db3qxe/jH/6@T8 "Java (OpenJDK 8) – Try It Online") Since Olivier [explicitly allowed](https://codegolf.stackexchange.com/questions/133174/make-your-language-mostly-unusable-cops-thread/133579?noredirect=1#comment328421_133579) passing input via properties set using VM arguments, I'll specify that the input should be given in the VM argument `-Dline.separator=X,Y`, where `X` and `Y` are the numbers to be added. That is, to e.g. add the numbers 17 and 25, the program should be invoked as: ``` java -Dline.separator=17,25 Main ``` I believe this should work on any system than can run Java programs on the command line. Even on systems that don't have a command line, any other equivalent mechanism for setting system properties could be used to pass the input to the VM. --- Ps. Here's my earlier cracking attempt, which was deemed invalid due to using JVM-specific features: ``` class SecurityManager extends sun.awt.AWTSecurityManager { static { String[] args = System.getProperty("sun.java.command").split(" "); int a = Integer.parseInt(args[args.length-2]); int b = Integer.parseInt(args[args.length-1]); System.out.println(a+b); } } ``` [Try it online!](https://tio.run/##lVZbb9s2FH7Przj2S2TUZXd7GGoMm7G1qIslHdYARRHkgaaOJcYUKZCUHc31b3cPdbN8yZLIsE2TPN/5zt33fMVfmxz1fbzcySw31sM97TFp2Hup8B@0mXROGj256B8rrhP2p@LOTaD/vHkD1wa8LaVOwGKMC6nDsrrKHoH42/AY7WQPYSz0Dk6lPntLoJMjxSRVH5wRKJ3H7FhgqmOIjb704FOplzCDhbGJ8VBfH5zBQVFY6ct3DwJzH7wScL6aAtYVTiZ1PIa1VApKU/x@CvBvob3McHJI5GPhfNANiTExZMhdYfGMt25Sa9Z8rnryJD27jCHlHsGbygD0YPSRuEbPPhuxRP9YRF1jGutfECEK1TlstnD@IQb3gb8zwebGoRmSXFaCWWuotTgg/wpucVEoVUJujUfhMSae2qNdcIFwxaWGzSNKKK@c514KmCuypPIXKRxcwDOeEG3lzBg@Blt@JQep8tmSXzEfw83sEyysRB2rkgQbKisjKWBEO6pT7/YO@IjSieLkoAsXbCpVHH4DjesmS29/uJucqKoygZwguMNKhkqpkQZos@@Ka56gBZe1gIcH0agTAfjj0wqtlTFCXsxVS1mkKJb7SEf7JeS07ANAwxc0aQuHjDLsmmcYjSa9S3IBEX1pRp6haH@RPo2GDv1wdNanKZZj8hP3l1WetNk3Bk31R2G17jg8374dgVvk8Rl0Aq9zMJxTnIrF4imk5FGaK26lKVzVIBKJjmIjVBEHd5AQ6hU7xQ4@onukQAs0Czjso3tsTeVKR@5phOPKHYUiqRGosNfGLg8wqvQ7SIyuX0XDa@r2g@FB6LYXp6v/SxtLENaXUyGoypvEhyWWh1nzBIvQASqYrpCJVDDqQ8iM2eWK@llqiiT1wOemoKqgNm3MAN6OXkb33QOKlqTI4heQvCpSHl4D6j2s77JW77bdqgcGk5oJZVyojKZjSZ0XvrlEpbzpjbVQRrVcbzMaMUWLaicaTknpVnAv0mjfS3DUteLQ/CHcryoGqm49hjk5a9bUAE1fL7mS/yH5b3DIlorzuHG4rLPyxUxpxqxnTc62rWELFXuIqmvXxr83hY47F5MtXTTIlr9MqP5QabURtQnCcpeyQ7i@NzqEOpbYaL4I7@1FPZ7JN4ZyI0WLg7D1gWbOW0LGMDZ57TiY0uD2Kf1sUkgYssYWwhvLKJaUh0RYF1n4o0HLbmyxXS1/3J7xgRpE7MAVmvG1Z9MvN8dXNvtJUluxnyI2cdRvm1BRANqqo6ZKeNXIFibLuKYeyFyupI@G0CYpcaumzYw4kh6Wc@uQfkQB9jZ8MIU68enrn@56IvNnifzYijTkqDhZTrS90hF/Na8OyfW73e7n3S/fAQ "Java (OpenJDK 8) – Try It Online") This turned out a lot less verbose than [the previous one](https://codegolf.stackexchange.com/a/133568). The hard part was finding a subclass of `SecurityManager` that didn't live in a namespace beginning with "`java.`". I suspect this is still not the intended solution, but it works.\* \) On TIO, at least; the `sun.awt.AWTSecurityManager` class and the `sun.java.command` property don't seem to be officially documented, and may not be available on all JVMs. [Answer] # [Jelly by hyper neutrino](https://codegolf.stackexchange.com/a/133203/31716) ``` + ``` Super simple. The Newline causes the first link to not be called. [Try it online!](https://tio.run/##y0rNyan8//9Rw5y0/CKFZIXMPIXk/JTU@ILE9FQrLoXMNIhYYkl@brEVmIxOjtVLTszJsfXLz0t91DD36KSwwzu4tP///2/83xQA "Jelly – Try It Online") [Answer] # [Python 2 by Wheat Wizard](https://codegolf.stackexchange.com/a/133220/48931) ``` import sys c="".join(open(__file__).read().split('\n')[4:]) if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1) sys.modules['sys'],sys.modules['os']=None,None;del sys;f=lambda\ a,b:a+b __import__('sysconfig').__dict__['os'].__dict__['sys'].setrecursionlimit(1000) print(f(1,2)) ``` [Try it online!](https://tio.run/##bY47bsMwEER7nkJQEXIRhZCNVDJ0hVxAFhiKn2QNfgSSLtzk6goVNQmQZhczu5g366N8xnDeNvRrTKXJj0zU2Lb8FjGwuJrAhLDojBDAk5GaAc@rw8LoNVCYXocZCNomm8IUvOyLNk/AOj5Ms3xX2uLNx5DKF4WY2oPSYmjUUFG8/iej7iljDA59jT0B2Q8@6rszeaJV0Ln7Y8XqjG8xmG4fF23cXvtiRyf9ouWVyG4Z5PNChDh4QrA9R8Vg8YMCF0Kjqu4R9Uv@wP4r1fc9kDVhKMyyU3cG2LZv "Python 2 – Try It Online") [Answer] # [Java by LordFarquaad](https://codegolf.stackexchange.com/a/133355/16236) Blocking the access to the objects at the source level was really smart (and annoying when testing), well done! ``` public class java { public static void main(String[] s) { //there is no executable code in snippet one. //your code here. try { ClassLoader cl = ClassLoader.getSystemClassLoader(); Object in = cl.loadClass("java.lang.System").getDeclaredField("in").get(null); Object out = cl.loadClass("java.lang.System").getDeclaredField("out").get(null); Object scanner = cl.loadClass("java.util.Scanner").getConstructor(cl.loadClass("java.io.InputStream")).newInstance(in); int i = (Integer)cl.loadClass("java.util.Scanner").getMethod("nextInt").invoke(scanner); int j = (Integer)cl.loadClass("java.util.Scanner").getMethod("nextInt").invoke(scanner); cl.loadClass("java.io.PrintStream").getMethod("println", Object.class).invoke(out, i+j); } catch (Exception e) { e.printStackTrace(); } } class Class {} class Method {} class System {} class FileDescriptor {} class Logger {} class Runtime {} class Scanner {} } ``` [Answer] # [Ruby by histocrat](https://codegolf.stackexchange.com/a/133456/12012) ``` BEGIN{exit(gets.to_i + gets.to_i)} ``` [Try it online!](https://tio.run/##KypNqvz/39XPpTq1IrNEwaCWy8nV3dMPzNNITy0p1ivJj89U0FaAszVr//835jIBAA "Ruby – Try It Online") [Answer] # [JavaScript by Daniel Franklin](https://codegolf.stackexchange.com/a/133452) ``` location="data:text/html;base64,PHNjcmlwdD5jb25zb2xlLmxvZygxKnByb21wdCgpKzEqcHJvbXB0KCkpPC9zY3JpcHQ+" ``` This might be considered a slightly cheaty solution, but it does work for me on Chromium 59 / Linux, even if I do also receive a warning saying: > > Upcoming versions will block content-initiated top frame navigations to data: URLs. For more information, see [https://goo.gl/BaZAea](https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/GbVcuwg_QjM). > > > Ps. Here's another crack, this time without warnings: ``` Node.prototype.removeChild=function(){} document.body.innerHTML='<iframe src="data:text/html;base64,PHNjcmlwdD5jb25zb2xlLmxvZygxKnByb21wdCgpKzEqcHJvbXB0KCkpPC9zY3JpcHQ+"/>' ``` [Answer] # [Inform 7, by Ilmari Karonen](https://codegolf.stackexchange.com/questions/133174/make-your-language-mostly-unusable-cops-thread/133686#133686) Blantant abuse of ambiguous nouns ... My code begins with `factory is a room`. The previous line is the cop's code. Type `add 1 and 1` to get 2, for example. ``` For reading a command: Rule fails factory is a room. The adder one is a thing. The adder two is a thing. The adder one is in factory. The adder two is in factory. Before reading a command: change the text of the player's command to "examine adder" For printing a parser error: if the player's command includes "add [number] ": let N be the number understood; if the player's command includes "and [number]": say the number understood plus N; ``` [Answer] # [Java, Roman Gräf](https://codegolf.stackexchange.com/a/133265/64109) ``` public class Main { public static void main(String... args){ System.setOut(null); System.setErr(null); System.setOut(new java.io.PrintStream(new java.io.FileOutputStream(java.io.FileDescriptor.out))); System.setErr(new java.io.PrintStream(new java.io.FileOutputStream(java.io.FileDescriptor.err))); System.out.println("This"); System.err.println("works"); } } ``` Sets `stdout` and `stderr` back to their initial values. I believe I am able to use the fully qualified name instead of an import, if I am wrong please correct me (this is my first post here.) This could probably be done using reflection as well. Edit: here's a reflective solution using only `java.lang.reflect.`: ``` import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Modifier; public class Test { public static void main(String... args) { System.setOut(null); System.setErr(null); try { Class<?> psClass = Class.forName("java.io.PrintStream"); Class<?> fsClass = Class.forName("java.io.FileOutputStream"); Class<?> osClass = Class.forName("java.io.OutputStream"); Class<?> fdClass = Class.forName("java.io.FileDescriptor"); Class<System> sClass = System.class; Constructor psCtor = psClass.getConstructor(osClass); Constructor fsCtor = fsClass.getConstructor(fdClass); Field modifiersField = Field.class.getDeclaredField("modifiers"); modifiersField.setAccessible(true); Object sout = psCtor.newInstance(fsCtor.newInstance(fdClass.getDeclaredField("out").get(null))); Field outField = sClass.getDeclaredField("out"); modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL); outField.set(null, sout); Object serr = psCtor.newInstance(fsCtor.newInstance(fdClass.getDeclaredField("err").get(null))); Field errField = sClass.getDeclaredField("err"); modifiersField.setInt(errField, outField.getModifiers() & ~Modifier.FINAL); errField.set(null, serr); System.out.println("This"); System.err.println("works"); } catch (Exception ignore) { } } } ``` [Answer] # [cQuents](https://github.com/stestoltz/cQuents), [Step Hen](https://codegolf.stackexchange.com/a/133207/44998), 3 bytes ``` +BC ``` [Try it online!](https://tio.run/##Sy4sTc0rKf7/X7nGUMfQylHbyfn/fxNzBVNjAA "cQuents – Try It Online") Took a lot of talking to Step Hen to figure out how the hell his weird language works, but in short: His code was `#\|1,1:A`. `#\|1,1` is the default input, meaning any input given to the program is appended by 2 1's. (IE if you pass a 47 and a 53, your input is `[47, 53, 1, 1]`. `:` simply sets the mode, which will output the `n`th item in the sequence if `n` is set, and otherwise output the entire sequence. Finally `A` gets the first input. Because we have 4 inputs `[47, 53, 1, 1]`, adding `BC` to the end would also fetch the 2nd and 3rd input, and the 4th input implicitly becomes `n`. Because our sequence is `ABC`, it's parsed algebraically, meaning it becomes `ABC`. We don't want that, but if we insert a `+` between A and B, it becomes `A+BC`, where `A` and `B` are our inputs, and `C` is 1. [Answer] # [RProgN2 by @ATaco](https://codegolf.stackexchange.com/a/133230/72137) ``` "+-/÷^"{²[[\=}; {"D"=11{‹1D&¬\D›]"D"=}:]1\2\Š1{[\D‹\|"D"=};D¬{1"D"=1\2\Š1{[D‹"D"=};}{[}?D}"~"={"d"="g"=g~d&gd~&\|}"±"={"H"="I"=11{‹H1&I1&±\H›"H"=I›"I"=H¬¬I¬¬\|}:1\2\Š1{[H‹\|"H"=};H}"×"={"J"="K"=1{JK&‹JK×"K"=]"J"=}:JK\|}"+"= ``` [Try it online!](https://tio.run/##PY4xDoJAEEV7T2Gm2EJCzGIH2dhsscARWKxI6NTQLkO8ha0HoNHGYLnEi3gRnMFgs5N9L/P/NOfmVB/DaJogCLeb8XkA5x9FYRUmKwcalJTucxmkFr63@nN5lQwxLqWN7PsmXcF0aGeaaN87OW8tluXPoStwrxE6UA4qUFCDqrtK1FUnWgR/Z26Ip0upkSKVwt@toV5WKU/Sxve@T/lpMf5XmfkOw10GYbxyXkZ5OeW5LBeks5ww/UsWGGc5FQegpmi9WwfTFw "RProgN 2 – Try It Online") This is by far not the best answer I could've given, but it allows adding numbers together again. Had I actually went through and did proper stack handling, I could probably golf this quite a bit, but as of now I'm happy with the answer. In ATaco's original post he effectively just reassigned all of the main arithmetic operators to destroy their inputs. To fix this problem I redefined what addition was in terms of its binary operations, which was a pain because [RProgN2](https://github.com/TehFlaminTaco/RProgN-2) doesn't have a binary negation operator or xor. Note: If you want to test the input, numbers with more than one digit need to be in the form `"XX..." n` to be converted into an actual number since RProgN2 takes each character as is unless it's a concept or string. Edit: @ATaco noted that adding a '$' before a multidigit number will do the same thing. EDIT: Here is the logic for my solution. As you can see, most definitely not the most refined code, but it works. ``` {"D"=11{‹1D&¬\D›]"D"=}:]1\2\Š1{[\D‹\|"D"=};D¬{1"D"=1\2\Š1{[D‹"D"=};}{[}?D}"~"= # Defines the ~ operator which negates a number {"D"= } # Remove the top of the stack and assign D with the popped value 11 # Push 2 1's to the stack. The first is used as a counter, the second if the initial truthy value for the loop { }: # Start a while loop if the top of the stack (popped) is truthy (removes final falsey value) ‹ # Left shift the counter variable 1D&¬ # Push negation of last bit of D \ # Swap the counter (index 1) and the negated bit (index 0) D›]"D"= # Push D, right shift it, duplicate the value on the stack, then pop and assign the top to D ]1\ # Duplicate the counter, push 1, and swap the counter to the top of the stack 2\Š # Push 2, swap with the counter, then take the log (log_2(counter)) 1{ }; # Run the for loop "for (i=1;i<=log_2(counter);i+=1)" [\ # Pop off i, then swap the original counter with the next bit to append D‹\|"D"= # Left shift D, or it with the next bit, then assign D the new value D¬ # Need to check if D was 0 or not (in the case of 0b11...1~) { }{ }? # Conditional on the truthiness of not D 1"D"= # If D was 0, we assign it as 1, then start to bit shift it up 1\2\Š1{ }; # Same for loop as earlier since the original counter is still on the top of the stack [D‹"D"= # Pop off i, left shift D, then reassign it [ # Else D was non-zero, so just pop off the counter we've been carrying around D # Push the final value to the top of the stack as a return "~"= # Assign the function between the {}'s to the character '~' {"d"="g"=g~d&gd~&\|}"±"= # Defines the ± operator which performs a single bit xor {"d"="g"= } # Assign d and g the first and second values on the stack respectively g~d& # Push ~g&d to the top of the stack gd~& # Push g&~d to the top of the stack \| # Or the top 2 values giving us (~g&d)\|(g&~d) "±"= # Assign this function to the ± operator {"H"="I"=11{‹H1&I1&±\H›"H"=I›"I"=H¬¬I¬¬\|}:1\2\Š1{[H‹\|"H"=};H}"×"= # Defines the × operator which performs a full number xor {"H"="I"= } # Store the top 2 stack values in H and I (in that order) 11{ }: # Another while loop with the first one being a counter for later, and the second is our truthy value to start the loop ‹H1&I1&± # Left shift the counter, then push the bit xor of H's and I's lowest bit ((H&1)±(I&1) in infix notation) \ # Swap the calculated bit and the counter H›"H"=I›"I"= # Right shift both variables and store the values back in them H¬¬I¬¬\| # Effectively pushing the value (H!=0 \| I != 0) 1\2\Š1{ }; # Same for loop as the ones above [H‹\|"H"= # Pop off the for loop counter, left shift H, or it with the next bit, and reassign H # Push the final computed xor value to the top of the stack "×"= # Assign this whole function to the × operator {"J"="K"=1{JK&‹JK×"K"=]"J"=}:JK\|}"+"= # Finally, a function redefining addition as the "+" operator {"J"="K"= } # Store the top 2 stack values in J and K respectively 1{ }: # An initial truthy value to start the while loop and the loop itself JK&‹ # Push (J&K)<<1 to the stack JK× # Compute the full xor of J and K (J^K in Python) "K"= # Assign K the value of J xor K ]"J"= # Duplicate (J&K)<<1 and assign 1 copy to J, leaving (J&K)<<1 as our while check (while ((J&K)<<1)) JK\| # Finally push the value J\|K to the stack to get the addition "+"= # Assign this function to the "+" operator, restoring it ``` [Answer] # [Java 8 by Olivier Grégoire](https://codegolf.stackexchange.com/a/133535) A hugely verbose crack for a hugely verbose challenge. :) The pain of working indirectly with classes that you cannot name is palpable. ``` try { Class loader = Class.class.getMethod("getClassLoader").getReturnType(); Object sysLoader = loader.getMethod("getSystemClassLoader").invoke(null); Class integer = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.Integer"); Class system = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.System"); Class filein = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.io.FileInputStream"); InputStream cmd = (InputStream) filein.getConstructor(String.class).newInstance("/proc/self/cmdline"); byte[] buf = new byte[65536]; int len = cmd.read(buf); String[] args = new String(buf, 0, len).split("\0"); int a = (int) integer.getMethod("parseInt", String.class).invoke(null, args[args.length-2]); int b = (int) integer.getMethod("parseInt", String.class).invoke(null, args[args.length-1]); Object out = system.getField("out").get(null); out.getClass().getMethod("println", String.class).invoke(out, ""+(a+b)); } catch (Exception e) { throw new Error(e); } } } class ClassLoader { public static ClassLoader getSystemClassLoader() { return new ClassLoader(); } public ClassLoader loadClass(String s) { return this; } public ClassLoader getDeclaredField(String s) { return this; } public ClassLoader getMethod(String s) { return this; } public ClassLoader getMethod(String s, Class c) { return this; } public InputStream get (Object o) { return new FakeInputStream(); } public void invoke(Object o, SecurityManager sm) {} } class FakeInputStream extends InputStream { public int read() { return -1; ``` [Try it online!](https://tio.run/##tVfdUxs3EH/nr1juhbuJOUjTZDplmDYlIaUTIFOY9oHyIMtrn/BZ8kg6kxvC3@6udDqf7vhIp238gC1p97cf@u2uuGErtquWKG8m87VYLJW2cEN7uVD5sSjxE@qFMEYoebA1OD6Ry8peWI1s0T@TaPMLxedon9I2yCstbJ3HArxkxsAvSpXIJNzdtxu1xW51VDDNuEXdbb1T1biMRN7LatGtjkvFbLc8kRZnsfZHJWfd6pTZoludVYtxLPuJ8TmbRaYuChdSt7RacNvHuKiNRecP7O0BneMErAKNE5wKieH4J/igFB3oOg9qlwXlddLB/KFEtHJJDJATBWfnl8BJnPLEvA8UUSNnC4pdGJAqJL5kcpYHkVRp0h7BuLJQqwpuldyxMCYQl07vZGXwgV62JSiHeso4UroE3ZRz40yBscwKDuOSrh6mBE6g2/C2NGTjN@fwD6BkWW9vQSt65Jz8qNiEknwEh/E6n6FtchNtptlBp7xyGVmQA2nj19U1sIwi1urWp0/d@jjuSAMoL4cg8TZk52r/@sBvXwQenjLJHCvMopXrH6RZwAH4@XyFWosJwpJo1/rBC@Tzjsxp9xOW9LNTh/aCJFlyRy7QM7bAJrbmI6aQ0pfMKVRtzZ/CFmli0CYZPPhQ7gusR/6qdwwsamiLa@SvnS5Bm@2tWOXLlwG0o9oj2J5djhOeisZW0@nzOLMnXVwxLVTlCEmxCzQgJC@riUsEKaFc5UNklxuSInjJUU2h34w6ZKlgSkfma/rDhkRX0upTv7pVeh4heBb1iPD@M8eldVebnFG73E6i67rf6n8/RxFNytrWbzlHYwJzYY51zJCvWIdlANkUGTnjQvnV8eBkZ0XFW6hqVliqZEXFLSxVs9qGH7Oeo/dNBOfjG@Qk5Ah5lFO3nPiKS5Oo8H0hJpnj6juk1kLt61hgOUkTIZvtVFZlGXISDYbc9yEncIrkFCnwUhkkHSFXao6pkI3vFJZwag1T/4EfLR6VxaBYk9GwfBsvNjadqyOq9eCusgXqAOe37gdNpidwt/ZXpOvNhXk3oWzaWGhiD@Omn1Ena2L4HW2l5WW9jKo/XIep28Z4GKAHYA@aY9KLb4PXeCfC2DuE1G9kj4BuUu4S6Ik5yNvGpxFElxImajKwaJq59y0stjToG3RdgEj8PxsMz6CI0s5uMBztAl9MnOloKwsuOQeOFHUiXXGrdNo3TGV@ErpUmuxRafM9g@V0j/BKeiB0UY7pHUQzblxNw4zyG29ev3715rqVoWuGEl0lk3ru2nZK8huIblDqmelNRCc2gv2R085ysyyFTZO/9jvrkQE3S6lubdayKs7wkmlD2bJPJbipPWf/yv3Jyd7MFrvfXWdxDONvYOLldXdxochcczwMTHUWQk@j7YdNDZx03lZx2utBS/LClvIph0iR6JS8SNmLcRbg7oEzywtIN60dsJsB3QR4rzVRBlst3502b@Ho@eQ0w7R55HH1@GOKJqD2Hchb6r@zvKkAGCN1fTnMLhPB0HQ3T2o@mB3/AiAk/L9rjkLT4M9BxOVNEJC2tBlk7pjN4wYxyJ4fIYEJLcDokZdn5p73m/9a@pCAn@mRNDE9l6IrdzXjq72lUPBu9@XB2jNmvX61/v5v "Java (OpenJDK 8) – Try It Online") Ps. Here's my earlier attempt, written before Olivier clarified that input was meant to be taken via command line arguments. Unlike the crack above, this one isn't Linux-specific. ``` try { Class loader = Class.class.getMethod("getClassLoader").getReturnType(); Object sysLoader = loader.getMethod("getSystemClassLoader").invoke(null); Class integer = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.Integer"); Class system = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.System"); Class scanner = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.util.Scanner"); InputStream in = (InputStream) system.getField("in").get(null); Object scanIn = scanner.getConstructor(InputStream.class).newInstance(in); int a = (int) scanner.getMethod("nextInt").invoke(scanIn); int b = (int) scanner.getMethod("nextInt").invoke(scanIn); Object out = system.getField("out").get(null); out.getClass().getMethod("println", String.class).invoke(out, ""+(a+b)); } catch (Exception e) { throw new Error(e); } } } class ClassLoader { public static ClassLoader getSystemClassLoader() { return new ClassLoader(); } public ClassLoader loadClass(String s) { return this; } public ClassLoader getDeclaredField(String s) { return this; } public ClassLoader getMethod(String s) { return this; } public ClassLoader getMethod(String s, Class c) { return this; } public InputStream get (Object o) { return new FakeInputStream(); } public void invoke(Object o, SecurityManager sm) {} } class FakeInputStream extends InputStream { public int read() { return -1; ``` [Try it online!](https://tio.run/##tVffb9s2EH73X3HxSyTUVTdsD0ODYOvSZMvQJEUdbA9FH2j6bDGWSYOk7App/vbsSFESJTvp0G1@sUnefXf33Q/Sd2zLXqoNyrv56lGsN0pbuKO9TKjsQhT4HvVaGCOUPBkNji/lprRTq5Gt@2cSbTZVfIX2KW2DvNTCVlkswAtmDPyqVIFMwv1Ds1FZ7FZnOdOMW9Td1ltVzopI5FyW6251UShmu@WltLiMtd8puexWV8zm3eq6XM9i2feMr9gyMjXNXUjd0mrBbR9jWhmLzh949QroHOdgFWic40JIDMc/w29K0YGusqB2mxOv8w7mTyWilSMxQM4VXN/cAidx4ol5HyiiWs7mFLswIFUgvmBymQWRRGnSnsCstFCpEnZKHluYEYij0ztZGtzTS0eCONQLxpHoEpQp58a1AmOZFRxmBaUeFgROoEfwpjBk4w/n8E@gZFEdjaARPXNOvlNsTiSfwWm8zpZoa26izSQ96ZS3jpE1OZDUfn38BCyliLXaefrUzsdxTxpAvJyCxF1g5@N3n0789jTU4RWTzFWFWTdy/YMkDTgAv9xsUWsxR9hQ2TV@8Bz5qivmpPsJG/rZqUOTIEmW3JEL9JqtsY6t/ogFJPQlMwpVW/OXsHkyNmjHKex9iPscq4lP9bGBdQVNc0182ikJ2hyNYpUvXwbQrtQOYPvqcjXhS9HYcrF4Hmf5pItbpoUqXUFS7AINCMmLcu6IICWU22yI7LghKYKXHNUC@sOoQ5YKFnRkvqY/HEiUkkaf5tVO6VWE4KuoVwjnnzlurEvt@JrG5dE4StfDqP/9XIloUta2esM5GhMqF1ZYxRXyFeuwCSBtk5EzLpTfXR1cHm@peXNVLnNLnayouYWlblZH8DrtOfpQR3Azu0NOQq4gzzKalnPfcck4anzfiOPU1epbpNFC4@tCYDFPxkLW24ksiyJwEl0MmZ9DTuAKySlS4IUySDpCbtUKEyFr3yks4dTqSv0HfjR41BaDZh1Phu1be9HadK5OqNeDu8rmqAOc33oYDJmewP2jT5Gu2oR5N6Gox1gYYvtx089oktUxfEBbanlbbaLuD@kwVTMYTwP0AGxvOI578bV4tXciXHunkPiN9ABoS7kj0BfmgLfWpwlESQk36nhg0dT33v9hsSmDgUHOpPzPQyytKLJpDe0sBpNRidedk0Q7aQjeWX6mTbpcE/ylAwkhOMEzRaNLl9wqnez1U0pPrN1lmG2@hRq/KM/@rqNNm8Z4DQMSP1vKWFcstfHWJQcw@zaAflBu8JzuE0Hbh5ig7azpkKTX3xvKki3kUwkjRUrV@EXCXszSAPcAnFmeQ9KOTcBuvnbT9VxrYhcbLd/57Tszepo4zTDJDzxcDj9U6HbRvru9pf4bxpsKgDFSN/PCvWAiGLo5zZOae3P5GwAC4f9ecxIakj8HETcQQUDSlM2AuQu2wkh2wJ4fz6ESGoDJgVdd6p7O7T@CPiRQQaOcm55LUcpdR7gHUPsGDN69/P7k0VfM4w@jH/8G "Java (OpenJDK 8) – Try It Online") [Answer] # [C# (.NET Core) by raznagul](https://codegolf.stackexchange.com/a/133279/14306) I assume this wasn't the intended solution. ``` int a; int b; using (var f = new System.IO.FileStream("/dev/stdin", System.IO.FileMode.Open, System.IO.FileAccess.Read)) { using (var fs = new System.IO.StreamReader(f)) { a = int.Parse(fs.ReadLine()); b = int.Parse(fs.ReadLine()); } } using (var f = new System.IO.FileStream("/dev/stdout", System.IO.FileMode.Open, System.IO.FileAccess.Write)) { using (var fs = new System.IO.StreamWriter(f)) { fs.WriteLine((a + b).ToString()); } } ``` [Answer] # [Java, by racer290](https://codegolf.stackexchange.com/a/133330/16236) This was rather a basic overlook that `static` initializers are called before the `main` method. It was a nice try: I was dismayed by the `throw new Error()` at first, but found the way in the end ;) ``` public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException { try { System.class.getField("in").set(null, null); System.class.getField("out").set(null, null); System.class.getField("err").set(null, null); System.class.getMethod("getSecurityManager", new Class[0]).setAccessible(false); File.class.getField("fs").set(null, null); for (Method m : Class.class.getMethods()) { m.setAccessible(false); } SecurityManager mngr = new SecurityManager() { @Override public void checkPermission(Permission p) { throw new Error("Muahaha!"); } @Override public void checkLink(String s) { throw new Error("Not this way, my friend!"); } }; System.setSecurityManager(mngr); } catch (Throwable t) { } // My code here, I guess... } static { java.util.Scanner s = new java.util.Scanner(System.in); System.out.println(s.nextInt()+s.nextInt()); // End of my code } ``` [Answer] # [Java by Kevin Cruijssen](https://codegolf.stackexchange.com/a/133348/16236) Well constructed. A lot of code to make anyone properly ponder how to solve this challenge. I guess the "put your code afterwards" was a big, big hint. ``` import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.FileDescriptor; import java.io.FilePermission; import java.io.PrintStream; import java.lang.reflect.Field; import java.lang.reflect.Modifier; public class Main { // Put everything in a static block so it is run before the static main method // and any trailing (static) initializer-blocks: static { try { initializing(); } catch (final Exception e) { } } static void initializing() throws Exception { // Overwrite System.out, System.err and System.in: System.setOut(new PrintStream(new ByteArrayOutputStream())); System.setErr(new PrintStream(new ByteArrayOutputStream())); System.setIn(new ByteArrayInputStream(new byte[0])); // Enable reflection for System.out, System.err and System.in: final Field modifiersField = Field.class.getDeclaredField("modifiers"); modifiersField.setAccessible(true); final Class<?> fdClass = java.io.FileDescriptor.class; final Field outField = fdClass.getDeclaredField("out"); outField.setAccessible(true); modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL); final Field errField = fdClass.getDeclaredField("err"); errField.setAccessible(true); modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL); final Field inField = fdClass.getDeclaredField("in"); inField.setAccessible(true); modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL); // Replace existing System.out FileDescriptor with a new (useless) one: outField.set(null, new FileDescriptor()); // Replace existing System.err FileDescriptor with a new (useless) one: errField.set(null, new FileDescriptor()); // Replace existing System.in FileDescriptor with a new (useless) one: inField.set(null, new FileDescriptor()); // Disable reflection for System.out, System.err, System.in again: modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL); modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL); modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL); inField.setAccessible(false); errField.setAccessible(false); outField.setAccessible(false); modifiersField.setAccessible(false); // Overwrite the SecurityManager: System.setSecurityManager(new SecurityManager() { private boolean exitAllowed = false; @Override public void checkExec(final String cmd) { throw new SecurityException(); } @Override public void checkPermission(final java.security.Permission perm) { final String name = perm.getName(); // You're not allowed to read/write files: if (name.equals("setIO") \|\| name.equals("writeFileDescriptor") \|\| name.equals("readFileDescriptor") \|\| ((perm instanceof FilePermission) && name.startsWith("/proc/self/fd/"))) { throw new SecurityException(); } // You're not allowed to overwrite the Security settings: if (name.equals("setSecurityManager") \|\| name.equals("suppressAccessChecks")) { throw new SecurityException(); } // You're not allowed to use reflection anymore: if (name.equals("getModifiers") \|\| name.equals("get") \|\| name.equals("set") \|\| name.equals("setBoolean") \|\| name.equals("setByte") \|\| name.equals("setChar") \|\| name.equals("setShort") \|\| name.equals("setInt") \|\| name.equals("setLong") \|\| name.equals("setFloat") \|\| name.equals("setDouble") \|\| name.equals("setFieldAccessor") \|\| name.equals("setFieldAccessor")) { throw new SecurityException(); } // When you try to leave the current VM it will stop the program: if (name.startsWith("exitVM") && !this.exitAllowed) { this.exitAllowed = true; System.exit(0); } // You know what, nothing is allowed! throw new SecurityException("Mhuahahahaha!"); } }); } public static void main(String[] args) { // Overwritting all given arguments: args = new String[0]; // Exit the program before you can do anything! System.exit(0); } } class System { static void exit(int n) {} static void setSecurityManager(SecurityManager sm) { java.util.Scanner scanner =new java.util.Scanner(java.lang.System.in); java.lang.System.out.println(scanner.nextInt() + scanner.nextInt()); } static void setIn(Object o) {} static void setOut(Object o) {} static void setErr(Object o) {} } ``` [Try it here.](https://ideone.com/sgcuaJ) [Answer] # [JavaScript by Grant Davis](https://codegolf.stackexchange.com/a/133383) ``` document.body.innerHTML='<iframe/>' w=frames[0] w.console.log(1w.prompt()+1w.prompt()) ``` Works in the JS console on the `about:blank` page (as specified in the cop post) on Chromium 59 / Linux. [Answer] # [C# (.NET Core) by raznagul](https://codegolf.stackexchange.com/a/133279) ``` var console = typeof(System.ConsoleCancelEventArgs).Assembly.GetType("System.Console"); var readLine = console.GetMethod("ReadLine"); var writeLine = console.GetMethod("WriteLine", new Type[] { typeof(int) }); int a = Int32.Parse((string) readLine.Invoke(null, null)); int b = Int32.Parse((string) readLine.Invoke(null, null)); writeLine.Invoke(null, new object[] {a+b}); ``` [Try it online!](https://tio.run/##nZBPS8QwEMXv@RRDTwlqD6438bAsIgsuiAoexEOajms0nSzJ2KWUfvaa2j@g4MU5DGHevN88YuKZ8QF70hXGgzYID01krEQrIJVxOkbYeIre4fdknA8VWbM1UHtbwk5bkmqR2r7WAcxogyvg5oD@VY7ofMJtNBl01zUSr8M@qnwdI1aFa/Ib5MfkkNlPQ6YuxcANqMtbSwN4OjE4dshvvpTZ/aTO28dgGf9ef5rl7BQIjzAcfn6Bds5siRV0iZUeoBNjS7w6z@90iChl5GBpr5ZI@ZZq/4GSPp1LvNTVZC3@Z13S/5JTUl@8o@Ehqz4pUsJ@/v1OjL3rL8RKfAE "C# (.NET Core) – Try It Online") This would probably have taken less time if I actually knew any C#. However, with some browsing of the documentation and [a bit of help from Jon Skeet](https://stackoverflow.com/a/1044472/411022), I managed to cobble together something that works. [Answer] # [Vim challenge by @DJMcMayhem](https://codegolf.stackexchange.com/a/133414/48198) It's been a while since I wasn't able to [exit vim](https://comic.browserling.com/20), here's my solution (note it's far more than `23` bytes - so it's probably not the intended solution): ``` i echo " 12 39 "\|awk '{s'$(python -c "print(''.join([chr(43),chr(61)]))")'$1} END {print s}'<Esc>vgg!bash ``` [Try it online!](https://tio.run/##XY27CsIwFED3/ILLbSjcBGuhVgSLioOugrM61No28ZHEptRH7bfXx@DgdOBw4FRtG2W6AAlSgTUnWTJcXWbRpIsebh4WOUlvKeA5NoC@9BHGSpsp/qzzp9U@00SSNBEaKAn6JBwR@oyvR8DaosvMvRRaQS8Bagqp3jv0D1oqtk5EwQYh9z4cBnzLOeXoBg0slnOovzHYBjtVnju72ArSti8 "V – Try It Online") The idea is simply to pipe the two integers to `awk` via `bash`, since `=` and `+` were disabled I had to use a small work-around. The `awk` line expands to: ``` "\|awk '{s'+='} END {print s} ``` Edit: The original intention was that the input is already in the buffer, but that wouldn't be more difficult - the main difficulty was to get addition working. Here's the suggested fix by @DJMcMayhem: [Try it online!](https://tio.run/##XY27CsIwFED3/EKX21C4DdZCrQgWFQfFTXFWh1r7iI8kNqU@qt8eH4OD04HDgVMbE2WyBA5cgFZHXrm4PI@jYQs9XN81MpJeU8BTrAB97iMMhFQj/Fn7T4tdJskiTQoJ1JpJ@ogvB8BGo@OqW1VIAe0EqCq5eJ/Q30su3FVSlG43ZN6HvYBtGKMMneAJ0/kEmm8M@olWnef2NtYFMSbokLD/Ag "V – Try It Online") [Answer] # [Java 7 by Poke](https://codegolf.stackexchange.com/a/133444) ``` } public static void main(java.lang.String[]a) throws Exception { int x = Integer.parseInt(a[0]); int y = Integer.parseInt(a[1]); java.lang.System.out.println(x+y); } } class String { } class System { public static java.io.InputStream in = new java.io.ByteArrayInputStream(new byte[0]), out = in, err = in; public static void setProperties (Object o) { ``` [Try it online!](https://tio.run/##hVNNj9NADL33V/hGKpZZlmvFASQOPbAglRvag5O4zbRTTzTjtA2ovz04k6Ttil04RDOxn5@fP2aLB3zna@JtuesKhzHCV7QMv2cAUVBska4A9/ewhEgECM4L@DVsNRSQ45FChGNFgWDt3S4C6q2JljeKXRXITAGUEkfCic6yFYvO/lJ37nyxg@jBkbyJkBMKSEV7EN@fUDdcVJqshEBYJtPahihQY8A9CYWJNae11/yKaKHCQ6@3qJALNXkDPzTQshCXVGo614j1rGIpQh38RrlU/abZE0vUanrddSMTN3J7xNYYkwx9/UYJnJmKjPARmI5/e7JVG4X2xvJ8kWLtGrJoKoyPdJJsPh@brD03nCwD7DxLh4T2AhiZfCOmcD7SBL14LL/ioBBe8USS70GXIIilmHHj3JQfChRtfPblVFCdekVXrdqRRy@VDnoUO3x1kztdm3F7Dt6WsNeVylYSFPrzCec6neCPEa6sAyWO/RuR758W3b8pU6Md8sb8n1zHDidNsNTxbygY3ZxI@pOhJprGopj2ZczDhLnJeR1FrdnFcXZ62ybYeXaeDa9pEKYaLoYUlUQ9LysRW2@W/cppGOky6rO5WSl1fm6FPoWA7Q0q6wG5OvpC7kD1aJDlO9CJp9vi5RY@Gztk3/ItFfqydcDdUMGs6x66D38A "Java (OpenJDK 8) – Try It Online") No Linux-specific tricks needed, just simple masking of the unqualified `String` and `System` class names. This is probably not the intended solution, but it works. [Answer] # [GolfScript by Ilmari Karonen](https://codegolf.stackexchange.com/a/133379/12012) ``` "#{var 'add', Gblock.new('gpush gpop + gpop')}"; add ``` [Try it online!](https://tio.run/##HcrJDoIwFEDRPV/xBPUxG8eF4LDzI1AjQy1GpE1bdIHw65W4usnNoay6y1w8uNJthzAaT6a243p@EM7i3f5wTM6X6@3bI27R7SNjvljCar0BsCAOAkiLAlRJJIG6eWVESFCMkuEIbVrtOxWAA0EfTlnF8mdYk4@NlDeyBMoZB@8fdDozMgao9Q8 "GolfScript – Try It Online") [Answer] # [JavaScript (Node.js)](https://nodejs.org) by [jrich](https://codegolf.stackexchange.com/a/133491/9365), 298 bytes I feel like this isn't the intended solution, but if it is, well done, I spent a while trying to figure out how to get the name of the declared function! :) ``` var p=process,f;(_=>{var w=p.stdout.write,n='f'+(Math.random()*1e7\|0),l=1 f=p.stdout.write=a=>eval(`(function ${n}(a){while(l&&((typeof a)[0]!='s'\|\|'f'+a!=n));a=l?l="":a;w.apply(p.stdout,arguments);})`)(a)})(); process.stderr.write.call(process.stdout,''+((0\|process.argv[2])+(0\|process.argv[3]))); ``` [Try it online!](https://tio.run/##XY/haoNAEIT/5ylMKHG3sZK0pYXKpk/QJwjSLHo2lsvdcXcqQX32q9IGSv7O7nwz880tu8LWxj8oXYoQWraRIWN1IZxLqgw@ad/PYkcmdb7UjU87W3uRKIqreAMf7E@pZVXqM@D9TrwOW0wk7RbVjYGY9qJlCUeoGlX4WqvorlcjMPbdqZYC5HoN4C9G6CpiPGzzJcUuHoY5h5ekEDMm@S5ptXrjrEvZGHmBa0rC9qs5C@UdZiMeceKOCJgt/sbMb8La3zJpwVLCv8sMiKc5sB2u6sRrD485bm61pxynKiGE5/DyAw "JavaScript (Node.js) – Try It Online") ]
[Question] [ The [Fibonacci Sequence](https://en.wikipedia.org/wiki/Fibonacci_sequence) is a sequence of positive integers where the first two elements are 1 and the rest are the sum of the previous two. It begins \$1, 1, 2, 3, 5, 8, 13\$ and continues forever. But what if you started with numbers other than \$1, 1\$? You could start with \$3, 4\$ and have the sequence go \$3, 4, 7, 11, 18, 29\cdots\$. Or you could start with \$2, 9\$ and have it go \$2, 9, 11, 20, 31, 51 \cdots\$. Your challenge is to take a list of positive integers and determine if it could be part of some Fibonacci-like sequence. Essentially, determine if for each element but the first two, it's equal to the sum of the previous two. ## Testcases Truthy: ``` [1, 1, 2, 3, 5] [6, 9, 15, 24] [49, 71, 120, 191, 311, 502] [3, 4, 7, 11] ``` Falsy: ``` [1, 2, 4] [1, 1, 2, 3, 4] [3, 4, 6, 8, 9] [3, 9, 12, 15, 31] [3, 4, 6, 10, 16] [1, 1, 1, 2] ``` You can assume the input will be (non-strictly) increasing and have a length ≥ 3. [Answer] # [Shue](https://codegolf.stackexchange.com/questions/242897/golf-the-prime-numbers-in-shue), 149 bytes ``` =R 1,R=<,R 1<=<1 ,<=, ,=, 1=i i=i ,,R=t,R it=t1 ,t=T, iT=T1 1,T=1, T=L L1=L L,=L LR =Xe 1t=e 1T=e i,T=e 1e=e ie=e ei=e e1=e e,=e ,e=e e=Xe XeR ``` [Try it online!](https://tio.run/##lVVRb9MwEH73r7DKA3FrCtbeqhmEoGNI04pKBpO6gtz0ulpK7Mh2Nqax3z7OSdul3Yq2VLr4zt99vjvfpeVNWFpzcK@L0rpAHXDqbzxxIKhErZ/ZotQ5JG7WSZLJLzn9e3EhWZclsq196DBC5rCglQGfqRISzQaE4uMgINGs06k13ETtXb1eWEczqg3VDTI@elFDlJnjlox@Fxedh@0VYW@1sWVvU9d6/phM7uGSL6cy@8Iyz@Pa8VbaA/2h8gqGzlmXLDrflPPgKER1QC9toNlSOZUFNN5md1Qt4gqrwLa599WtCUS0wB6eTOEmgE8m2bTh3Y32WZEORydvh6Oj3RjxgMqZ@CJNt5TRc9MqiC20UcE6j5F6CMnKrcph25JrU1t035e5Dklddrbpqjx2VY15iLuo21n0CxWyZZKzdssV/UtnqzI5YDsFiQf/lfQ22bT1GioY4/SR9YBNxGDK2N1/qtzKMlI/xXzXrlYLz5uImtrBH8iqAEnGabuAaxCm21Q3a1KtjL4C1NF@q5sDCjtHLXUV1Or1Euc8GltFqxFHCpPY2Axc/26RPVzKuvo@Vn@N2M4da13v1oEOVgn6l3jj96gyeOGvx68ZfU/FILMmaFPBFjISKT6LVHUxtnnWCFvvK3MJSQ4m8awn2GPk@uSJHdhexCk2jSOmnobulijesZ8M7LQ36yHHimEwvdvrvXMtO5fX5ib7BtLZS6eK9UQai71U5iqDAkzwVDmgpfVez/C@sbWxm3BW5nQGS3WlbeVY/Jq/oj8/jk@/nn6hn0enKT37PqRHozEdpcfDMf1@fDakn0afhySzcwwLv@@dezkmgo/lIcf3oTwUhB/KLie8G6XoSk00LjXhCAoI0kEGBAWZcqJTmQp0T6XgJJUn5EREwaMYk648ByKCRJGi0DxKAXEZBegoRBQcBa9t0eUcxvcYGQ7lGzF9bkaEaFPGzr7xfR/m2vQdqHnC@mBistjt@O8Y52szgWjFITQlI6XT2J243Z9DA2b3guNPCP4P "Python 3 – Try It Online") Returns "LR" for yes and "XeR" for no. Previous version didn't work for inputs like `1,1,111,` so a few bytes went into fixing that. # Explanation ``` =R - Right edge 1,R=<,R - Spawn a triangle and decrement the last number 1<=<1 - Triangle passes trough the last element ,<=, - Triangle turns into star after last element ,=, - Star passes trough commas 1=i - Reversibly "Decrement" the element (i=0) i=i - Star passes trough zeros ,,R=t,R - When done, send a test probe (t) it=t1 - Test probe passes trough zeros, turning them to ones ,t=T, - Upgrade test probe iT=T1 - Still passes trough zeros 1,T=1, - And when done, delete itself T=L - Or, if the left edge was reached, turn into L L1=L - L deletes everything to it's right L,=L - --\|\|-- LR - And finally, success =Xe - Or, if the star reached the end, create error 1t=e - Or if there weren't enough elements to delete last time, create error (b>c) 1T=e - Same as before (a+b>c) i,T=e - Too many elements to delete (a+b<c) 1e=e - Errors propagate ie=e - --\|\|-- ei=e - --\|\|-- e1=e - --\|\|-- e,=e - --\|\|-- ,e=e - --\|\|-- e=Xe - Unify error types XeR - Final error state ``` # Example run: ``` 1,1,11, 1,1,11,R 1,1,1<,R 1,1,<1,R 1,1,1,R 1,i,1,R 1,i,<,R 1,i,,R 1,i,,R 1,i,,R i,i,,R i,it,R i,t1,R iT,1,R T1,1,R L1,1,R L,1,R L1,R L,R LR ``` # Example run 2 ``` 1,1,111, 1,1,111,R 1,1,11<,R 1,1,1<1,R 1,1,<11,R 1,1,11,R 1,i,11,R 1,i,1<,R 1,i,<1,R 1,i,1,R 1,i,1,R 1,i,1,R i,i,1,R i,i,<,R i,i,R i,i,R i,i,R i,i,R Xe,i,R Xei,R Xe,R XeR ``` [Answer] # [R](https://www.r-project.org/), ~~46~~ ~~41~~ ~~42~~ 38 bytes Edit: Bug-fix for +1 byte thanks to pajonk, but then -4 bytes by adopting [Giuseppe's](https://codegolf.stackexchange.com/a/242967/95126) use of `head` with a negative `n`... ``` function(x)any(diff(x)[-1]-head(x,-2)) ``` [Try it online!](https://tio.run/##dY7LCsIwEEX3/YosE0igk0e1C79ERGrbYFBSkAr16@ONbiqxMAwD9zHnkeI0n3243MNtPCT/jP0cpsgX0cUXH4L3OI@KTuo6dgNfpNJCrDO85yQZRktmJHNCVL9qI1kLg4PDFqKFtMt5XWO1uAxhuVoXVpRbmGEjaFWBgP9l/xrNblQCcA/Gf2oG1194Q9txyvBNSWU@fyGkNw "R – Try It Online") Function `not_fiblike` outputs `TRUE` if the input `x` is not a fibonacci-like sequence, `FALSE` if it is one. [Answer] # [Wolfram Mathematica](https://wolfram.com/mathematica) ~~34~~ 29 bytes ``` 2#~Drop~2==MovingMap[Tr,#,2]& ``` –5 bytes from @att [Try it online!](https://tio.run/##VU09C4MwEN39FYGA05WaS7R1sDh0FTp0E4dQauvgByJdgv719A6lUjiOex/3Xmun97O1U/Owvs48yuU69sOCWVb0n6Z7FXYo7yNIwCr0t7HpplIeLnUuq/CYu8ApEDQIQoOIZwhcAiIlLibSMDaETuzCiFZKl1a04ghZpS9DOimK4RpltvMXbHYrxZ@pYSO4Cdc2rf5MituSPYiz5mD2Xw) [Included the `[3,4,6,10,16]` and `[1,1,1,2]` falsey test cases from Noodle9 and DLosc, respectively.] [Answer] # [Python](https://www.python.org), 31 bytes ``` def f(a,d):a+d[0]-d[1]or f(d) ``` [Attempt This Online!](https://ato.pxeger.com/run?1=TZBNDoIwEIX3nGKWoCWhUBRw7wncERaNtJHEAMGSyFncsNFreA4TD-Pjz5A0kzff_LxMH6-6M5eq7Ptna7QbvXOlSduSbXInkds89TI3T3lWNaBgU9fnqwEkFSWlFqWcEZ7PKGAUZgxkxygGDEHFCATS_dDnewgxVMARQs8fyxgUaECJj_m8bqXFov9OYjUJvwiWCxm8_ck_GBZmiUWm6RKcIJ1D3RSlsY_yelOORep-VrVJJnhqWjXfuPzIDw) -3 bytes thanks to @emanresuA. Outputs via presence of an exception or not. [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~43~~ ~~38~~ 31 bytes ``` #[[;;-3]]+#[[2;;-2]]==#[[3;;]]& ``` [Try it online!](https://tio.run/##VU1LCoMwFNx7ikDATSM1P1sJFo/QvbyFlEpd6KJkFzx7Og@lpRAe88vMMsbXcxnj/Bjz1GU5DCFUlugEZAANUdcB2xCIynx/z2scZHWbeknluU9F0krgGSWsEn5TRWqUaKF5iI65A7twytQ4LZDVOL427OKXgw9HM92r3AG/xe4XRf0VC4fAS2Zfs/ovpHmt2YotfwA "Wolfram Language (Mathematica) – Try It Online") Previously I had a 43-byte version using Partition, which simplifies to a 39-byte solution with BlockMap: ``` And@@BlockMap[Plus@@#==2#[[3]]&,#,3,1]& ``` In case it gives anyone ideas, there is a 44-byte solution using a function specifically for generating linear recurrences: ``` #==LinearRecurrence[{1,1},#[[;;2]],Tr[1^#]]& ``` [Answer] # [R](https://www.r-project.org/), 40 bytes ``` function(l)any(diff(l,2)-head(l,-1)[-1]) ``` [Try it online!](https://tio.run/##NYxBCsIwFET3PYXL/2ECnZ9GCXgTcVFag4USQXTh6WOCZjePmXnPkg5nV9I7L6/tkWXXOX9k3VKSHabufpvXmhz14njVkmQRgjB4BNWh8RERDLDpz1PEqW5sBCPhSYTRajf8zoY@7KLOvomsuTxVyxc "R – Try It Online") Returns `FALSE` for Fibonacci-like sequences, and `TRUE` otherwise. Slightly different approach than [Dominic van Essen's](https://codegolf.stackexchange.com/a/242953/67312), takes the lag-2 differences of `l` and compares to the list with the first and last elements removed, relying on the following idea: \$F\_{n+1}=F\_{n}+F\_{n-1}\Rightarrow F\_n=F\_{n+1}-F\_{n-1}\$ [Answer] # [Jelly](https://github.com/DennisMitchell/jellylanguage), 4 bytes ``` IḊw@ ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m700KzUnp3LBgqWlJWm6Fss8H-7oKndYUpyUXAwV2hitFG2so2Cio2Cuo2BoFKsUC5UAAA) ``` I differences between consecutive elements Ḋ remove the first item w@ find the sublist index of this in the input ``` `1` is truthy and all other values are falsey. [Answer] # [Pari/GP](http://pari.math.u-bordeaux.fr/), 27 bytes ``` a->#Pol(Ser(a)(1-x-x^2))<3 ``` A sequence is Fibonacci-like if and only if its generating function is of the form \$\frac{a+b\ x}{1-x-x^2}\$. [Try it online!](https://tio.run/##RU1LCsIwFLzKo24SSaD5VC1ozyC4LBGysFIoNQQX9fRxHi0K4TG/zKSYR/1MZaBLibrbXV@TuD2yiHIvjF70crdSnl2JKU0fEUl3lPI4vwErJhUNyEpFfW8U4VlFTlEToBwUtdAaiJ65BztyytY4LZAzOE1t2cUvDx@OYbpW@Q3@iv0/ivoTFjaBl@y65kwIsnwB "Pari/GP – Try It Online") [Answer] # [Julia](https://julialang.org/), ~~48~~ ~~44~~ 43 bytes ``` ~f=0∉3:length(f).\|>i->f[i]==f[i-2]+f[i-1] ``` [Try it online!](https://tio.run/##VY1NCsIwFIT3OUWWLabS/FStkF4kZOHCp5FSRCK4kK71ml4kTihChPCSmbxv5nIfw0E@UprJtp/XW@/H43SK54rq9XMIzUAueGsxG@VX@ZI@RWmdFBxHCa4F7zyLyrqN4D3cDraBo60z0Nu8qVqMHi8tMbpW4d9YB9ZgA3/SM0ZLLDKBk/rvyJb@EWjaoQzWEpJr1VKtc9L1FqY4TtUcZV0IVQpdClOzgqKSopKikiJQ6Qs) [Answer] # [JavaScript (Node.js)](https://nodejs.org), 32 bytes -1 byte by [l4m2](https://codegolf.stackexchange.com/users/76323/l4m2) ``` a=>!a.some(n=>n+a[i]-a[++i],i=1) ``` [Try it online!](https://tio.run/##dY/LCsIwEEX3fkXcNTQtzaNqF@mPhC5CbSXSJmLF3483FFxIhGEYOIeZO3f7ttv4dI9X5cN1irOOVvdHW29hnQqve19a44bKmrJ0A3Oa0zgGv4VlqpdwK@bCcEZQghHJSDtQevjhJ0Y6KC0clcEK8Jx2iAatwyQ5WtuIjIwTCjpEnqF7DJUn34zq714kvSBsnqcfxP6HTMfjBw "JavaScript (Node.js) – Try It Online") [Answer] # [Dyalog APL](https://www.dyalog.com/), ~~11~~ 10 bytes ``` ⊃2∘↓⍷2+/⊢ ``` -1 thanks to @DLosc. [Try it online!](https://tio.run/##Pcw9CsJAEMXxq7xyBwlmZj/iHmeJKMKCQiprIUhAEGysrbyBvUeZi8RdRLsHP94/HXKzPqa83zZ9TsOw6@d5o@NVp5Po@a7jTS8vWSx1ehR4Pw2DIbDwZAIi2EMcGRfRFZEWHBmWGb4VMhYOHZjJ1JOj/9t9LWCFWGcJSW1Z/gGXVKAP) Taking the array `1 1 2 3 5` as an example: ``` 2∘↓ Is the array with the first two elements removed (2 3 5) ⍷ a subarray of 2+/⊢ the sum of each consecutive pair of numbers in the array (2 3 5 8) ⊃ at the first position? ``` [Answer] # [Haskell](https://www.haskell.org/), 34 bytes ``` g(a:l@(b:c:_))=a+b==c&&g l;g _=0<1 ``` [Try it online!](https://tio.run/##dY7PCoJAEIfvPsUgIUp7cP9oaS106gm6hchqsUqbhdqhp99GosgsWIad/X4z@1WqOx2NsVb7KjUbv0jLNA8CqeaFlKXnaTArDbkM19SeVd2AhMPFgWtbNz24u/bWV3f31c9Aw54SwMMIcAJRNkIxgQRphFiMicD3xTDJQiwJ3jjFEoVsnMOdApOYoZnz1tgq000tUOHrl0818WsxCi7RcYIGa/Y05/TPIB3M48w@AA "Haskell – Try It Online") * Thanks to @Laikoni for suggesting a recursive approach 1 Byte shorter * Original solution 35 bytes ``` g l@(a:b:c)=zipWith(-)c l==b:init c ``` [Try it online!](https://tio.run/##dY7RCoIwFIbvfYqDdKGwwM2pKQy66gmCLsKLaeFGy0TXRb38OhJFZsE47Oz7z9mn5HA6GuNcA2YdyKIq6lDcdbfTVgXLsAYjRFXoVluo3VnqFgQcLh50vW4t@Nv@atXNf/ULaGBPCeBhBGICSTlBKYEcaYKYTwnH92ycZBGWHG8xxZJEbJrDnRyTmKGl99bYSDPMLVDh65dPNf5rMQqu0HGGRmv2NI/pn0E6mqelewA "Haskell – Try It Online") [Answer] # [Curry (PAKCS)](https://www.informatik.uni-kiel.de/%7Epakcs/), 22 bytes -3 bytes thanks to [Wheat Wizard](https://codegolf.stackexchange.com/users/56656/wheat-wizard). ``` f(_++a:b:c:_)\|a+b/=c=0 ``` [Try it online!](https://tio.run/##Sy4tKqrULUjMTi7@/z9NI15bO9EqySrZKl6zJlE7Sd822dbgf25iZp6CrUKaQrShjgIQGekoGOsomMT@BwA "Curry (PAKCS) – Try It Online") This returns nothing if the input is Fibonacci-like, and `0` otherwise. [Answer] # [Python 2](https://docs.python.org/2/), 39 bytes * -3 bytes by [loopy walt](https://codegolf.stackexchange.com/users/107561/loopy-walt) ``` lambda a:map(sum,zip(a[1:-1],a))==a[2:] ``` [Try it online!](https://tio.run/##bY7dCsIwDIXvfYpethBh/VNX6JPUXkRkOLCz6LzQl68pg0GHEEI45yT58me@PSZVBn8ud0yXKzJ0CTN/vRN8x8wxSLeXEVAI7zEoF0t@jtPMBx4kMCoFTAOzUYjd6hyA9WRack1jGJKPdU911HqatKRmO9XE6KChIEVkoy/vzFZbKcyfK8RyIpytU/nUwqjrk/ID "Python 2 – Try It Online") --- # [Python 3](https://docs.python.org/3/) + [NumPy](https://numpy.org), 35 bytes ``` lambda a:all(a[1:-1]+a[:-2]==a[2:]) ``` [Try it online!](https://tio.run/##fY/dCsIwDIXvfYpctlhl/Zm6wp6k9iIiw8HWlTov9vQ1c@CVFUII5EvOOXGZH1PQuWuvecDxdkdAi8PA0El7kH6Pzh6Ub1t0ynqe@zFOaYbwGuMC@IQQdzH1YWYdC/GIKeHCnBRApQRoAbXnnP9gTgIawmriTAExBJzXX6qi1tCkJbW6UoUDkjN0QrAsEJstU95@fZu/GuT@QgHKzJpNbfn0x0x@Aw "Python 3 – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` ¥¦Å? ``` Port of [@pxeger's Jelly answer](https://codegolf.stackexchange.com/a/242936/52210). [Try it online](https://tio.run/##yy9OTMpM/f//0NJDyw632v//H21iqWNuqGNoZKBjaGmoY2xoqGNqYBQLAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXL/0NLDy073Gr/X@d/dLShjqGOkY6xjmmsTrSZjqWOoamOkQmQbWKpYw6UMzLQMbQ01DE2NNQxNTACihvrmOiY6xgaApkgjSZgGmKECVTaTMdCxxLMBhpnBDLR2DA2FgA). An inversed version is also possible, but would be a [byte](https://github.com/Adriandmen/05AB1E/wiki/Codepage) longer: ``` ü+¨Å¿ ``` [Try it online](https://tio.run/##yy9OTMpM/f//8B7tQysOtx7a//9/tImljrmhjqGRgY6hpaGOsaGhjqmBUSwA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXL/8N7tA@tONx6aP9/nf/R0YY6hjpGOsY6prE60WY6ljqGpjpGJkC2iaWOOVDOyEDH0NJQx9jQUMfUwAgobqxjomOuY2gIZII0moBpiBEmUGkzHQsdSzAbaJwRyERjw9hYAA). Explanation: ``` # e.g. input = [49,71,120,191,311,502] ¥ # Get the deltas/forward-differences of the (implicit) input-list # STACK: [22,49,71,120,191] ¦ # Remove the first item # STACK: [49,71,120,191] Å? # Check if the (implicit) input-list starts with this sublist # STACK: 1 # (after which the result is output implicitly) ü # For each overlapping pair of the (implicit) input-list: + # Add them together # STACK: [120,191,311,502,813] ¨ # Remove the last item # STACK: [120,191,311,502] Å¿ # Check if the (implicit) input-list ends with this sublist # STACK: 1 # (after which the result is output implicitly) ``` [Answer] # [MATL](https://github.com/lmendo/MATL), 10 bytes ``` d4L)tfGw)= ``` [Try it online!](https://tio.run/##TY3BCsIwEETvfsVcC0GTzabaQ/Ei2IN48lBaAgoiCHor1L@PEwNFCMvOzObN@za90vWJvsNwxh5rRHRIdz1V0@M4V23qDxg@uMQ0OgM@MfAGIa7G2qChFegppVJs841YjoabdxzBCkN@UcYMHFXBaNkWpi53JO8ILzp3SOnx7v/E5Z6ajvwIhWg39gs "MATL – Try It Online") Just the usual: take the pairwise difference, discard the first, chop off the last two elements of input, compare. --- Alternate: ### [MATL](https://github.com/lmendo/MATL), ~~17~~ 16 bytes ``` tnwTTZ+2YSG=s-I< ``` [Try it online!](https://tio.run/##TY0xC8IwFIR3f8XtRk1ekmpBcRGsi4sZakpAR0FdLOi/j1cDRQiPd3cv3z2u/T1fbmgbxCO2mCOhQe6f7xDiVM6n/eY1O6xzu0P8IKTcGQU@UbAKPk26SqGm5ek5SkexHG5Ec9TcrOHwWhjyi2PMwFAVjCvbyHTjHckrwoseOqT0WPN/Yoaeio78CIWoF/oL "MATL – Try It Online") Perform a convolution of the input with `[1 1]`, circularly shift the result twice to align the sums, compare with input, and see that the last `n - 2` values match. (The last two bytes might as well be `2=` I think, but it's the same byte count anyway.) Previous solution: `TT2&Y+3L)G&m2-tf=` Perform a convolution of the input with `[1 1]`, and check that the 1:n-1 values of the result (excluding the last sum) are present in the input at right index. --- Output is all 1s (in both solutions) for truthy. [Answer] # [Husk](https://github.com/barbuz/Husk), ~~5~~ ~~6~~ 5 bytes ``` €¹tẊ- ``` [Try it online!](https://tio.run/##yygtzv6f@6ip8f@jpjWHdpY83NWl@////@hoE0sdc0MdQyMDHUNLQx1jQ0MdUwOjWJ1oEwvs4oY6RjomsbEA "Husk – Try It Online") Outputs `1` for truthy (it's a fibonacci-like sequence), any other non-negative integer for falsy (it isn't a fibonacci-like sequence). Get the pairwise differences (`Ẋ-`), remove the first one (`t`), and ~~check if this is an ordered sublist of the input~~ find the index of this sublist in the input (`€ḣ¹`), or `0` if not present. ~~Of course, it needs to be a prefix of the input (rather than a sublist at any other position), but I think this should be ensured since the input is increasing.~~ Edit: the fact that the input is increasing does not ensure that sublists must be prefixes (consider `1 2 4` with difference sublist `2`), so we check this by requiring that the index of the sublist must be `1`. [Answer] # 80386 machine code, ~~19~~ 16 bytes ``` \x49\x49\x8b\x44\x8a\x04\x2b\x04\x8a\x2b\x44\x8a\xfc\xe1\xf3\xc3 ``` [Try it online!](https://tio.run/##hVHtasIwFP3dPMUlMki26vrl15xj77FKSdNUA7UdbRxF8dXX3VgZIrpBmntucnrOuUQO11J2A13KYpcpeG1MpqvR5q1LEmFMrdOdUUnCWKOk0VXJ6Mio1lDOOciNqCHV5ccKloTGbTTvv1mKNcIq4tbDGqR9tX1wcZfLuFU@1jBuZUgX15a5aIwURYFWjRFGS9ClAaMak@uUWSzd09Gj4HAgjoX1gjgo02yTBL6qAv8qFDDiONQq2bT0xXbLdyn3FFjNXds@ScTyjDPEghOHo1atzK4ureyRkEGmcl0q@KzRirW8BzmjD1lcUvc3WqP3qsot4RkiF1rOCbHhtkKX7BS1V2CnIT5W/OC7gCtwIXRhfOTW@ZoycWGOrDHSotuMCO@nVinwcJsjCn3cxl5wm49emG6KXP9EuBkLM92xu8wc/eWAyWcY/i7FjhX0o4X@P0K@HW3Sk85v49m36bpvmRdi3XTDbRj8AA) Applying @PeterCordes's suggestion to remove `setz` saved 3 bytes. I first considered simply returning `al` as a boolean value, but then the problem is that a non-zero value will represent `false` and zero will represent `true`. I felt it's not clear-cut whether this is okay. Now, the function works as returning the zero flag. Thus, it is not possible to be directly called from C as before. If you follow the TIO link, there is a wrapper function to interface with this assembly function returning a flag value. Since I'll usually have to write such wrapper when calling functions from other languages, I think this approach is okay. Thanks to @Deadcode for letting me know a nice way to translate the flag to a value in the wrapper function. assembly (nasm) ``` testfib: ; fastcall, ecx = length of array, edx = pointer to array dec ecx dec ecx .loop: mov eax, [edx + ecx * 4 + 4] sub eax, [edx + ecx * 4] sub eax, [edx + ecx * 4 - 4] loopz .loop ret ``` [Answer] # [Desmos](https://desmos.com/calculator), 37 bytes ``` f(l)=min(1-sign(l[3...]-l[2...]-l)^2) ``` [Try It On Desmos!](https://www.desmos.com/calculator/gc4zlbve6p) [Try It On Desmos! - Prettified](https://www.desmos.com/calculator/2xdy0dyg2c) Tell me if there is anything wrong. I made this answer faster than usual :D [Answer] # [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 46 bytes ``` f=lambda n:n[2:]and(n[0]+n[1]-n[2]or f(n[1:])) ``` [Try it online!](https://tio.run/##ZY7NCsIwEITveYo9Nhih@am2BZ8k7KFSgoW6ltKLTx8nKqgIYcl8k8zsct8uN/HtsuacTvNwPY8DSS/R9TzIWEmseSfR8h6IbyslINuz1jlBzTQJxWgN4ThD3lDDRsWDoQ6sAQxFB6hjeeVqjA43bzGa2hUXvwJ8OJa5V7Ssk2xVqmatlfqtQccz8LsxfDLQ26L6DcoK7rWG/0vODw "Python 3.8 (pre-release) – Try It Online") Recursion is shorter than doing `all(... for i,e in enumerate(n))`. -2 by @emanresuA, -4 by @pxeger. What am I doing today... [Answer] # [Factor](https://factorcode.org/), 30 bytes ``` [ dup differences rest head? ] ``` [Try it online!](https://tio.run/##VY6/DoIwEId3nuL3BIaWAqKDo3FxMU7GoYEjEAVrewyG8OxYgkG9m@67P9@VOueHHc@nw3G/QaO5WjnWXDuuc4cb2ZbucPTsqM3JwVhifhlbt4xtEPQBfPQQPiUixBg@JEEGEUOqhagMqZ@TIUQmEAmBOJRLN4JCCg@H5aSE@qlmgfpbSLD2mi/xSjlZo@nMEIwXFJ1BUZcl2fl/S45RkS52uI6NNliNbw "Factor – Try It Online") ## Explanation Does the input start with its differences sans the first? ``` ! { 1 1 2 3 5 } dup ! { 1 1 2 3 5 } { 1 1 2 3 5 } differences ! { 1 1 2 3 5 } { 0 1 1 2 } rest ! { 1 1 2 3 5 } { 1 1 2 } head? ! t ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~58~~ ~~57~~ 51 bytes ``` r;f(a,n)inta;{for(r=0;n-->2;)r\|=a+++a-a[1];n=r;} ``` [Try it online!](https://tio.run/##ZZPbjpswEIbv9ymmSJE4GBXMKanL9qLqUyRcIGK2qK2zwkiNmubVSwcGiL2LHA/m@z3zewJN@NI049iL1q2Z8jo1@LW4tZfe7ctIqDB85sLr/5Z@HfhBUIf1Ma6EKntxH1ELv@pOuR7cngCv6cEg9RAfKyjhFjPAwRkkDLK72DAnnDM4oCJDSWrQhGiKrJgy8AinA94lMU5ZxA1tSlrMn6IadbEBs80FWjAr5O/tmbgwk6LJeDKQG4L9Jpj8czpDgqXXJvizTJNsbgijg1NIKKQUMgo5hYLC/pFsXivKpbs/8tK6c0rv47LyacnAoNym3KaJTRObpjZNbZrZNLNpbtPcpoVNC5vubbr3jB7I66tsBnk2/zka0TYWeXNReoDme937OMvmh@xpl3O6fuOn6@Er/jKHgblOnGU3vvjgThU7dZZX3BaJ5fbz6nX18rC7PREQBLPam5PRV/F4KTAdvRizphImBrVQ9Y4@PC1@0IuaS3mbZrpeexS1rrPTuzOer/syHfKTc8QwHLvKs@tpTPYBO48fvQ0kgq3fb72sNSoIn2F3hp0@Kcyv2dZrXZZyrXV/uo//mvZn/aLH8Pd/ "C (gcc) – Try It Online") Saved 6 bytes thanks to [pxeger](https://codegolf.stackexchange.com/users/97857/pxeger)!!!* Inputs a pointer to an array on integers and its length (because pointers in C carry no length info). Returns \$0\$ if its a Fibonacci-like sequence or a truthy value otherwise. [Answer] # [C (GCC)](https://gcc.gnu.org), 44 bytes ``` f(a,n)inta;{n=a+++a-a[1]\|\|--n>2&&f(a,n);} ``` [Attempt This Online!](https://ato.pxeger.com/run?1=XZBRSsQwEIbf9xQx4pJpk7pJ09W1rN5hX2uRUBMpaJRtFsHunsSXfVnv5DU8gRMaEIQwzPzzzzdMPk_dw1PXfTVUvNP2eNoFJ66_uWOGe-h9yEw9-nVm8izPjTCNbPd7Ifytms8nT31IMz_nj9b13pINM0VRwIjTJDTtejSH-m2LlWP0Yrj3lJ85FvjQf9hXTOAyZegAuKNhu7P0hjrzPFiK-NmL6T2DcbZhkhN8ipOSkwpQWHKyQq1CUcdaY3UVXWqBYYVZKTFUCxW7OKWxjx0JEw1RGv6B9Z8V8TKClkmKu9S0r0REuvyYfu0X) -1 byte by inverting output, thanks to @AZTECCO Recursive. [Answer] # [BQN](https://mlochbaum.github.io/BQN/index.html), ~~14~~ 13 bytes ``` +´↑∊·2⊸↓⊸⋈⊢-» ``` [Try it at BQN online REPL](https://mlochbaum.github.io/BQN/try.html#code=RmlibGlrZSDihpAgK8K04oaR4oiKwrcy4oq44oaT4oq44ouI4oqiLcK7CgpGaWJsaWtlwqgg4p+oMeKAvzHigL8y4oC/M+KAvzXigL844oC/MTMsMeKAvzHigL8y4oC/M+KAvzXigL844oC/MTTin6kK) ``` » # shift the input array right, - # and subtract this from ⊢ # the input; ·2⊸↓ # now drop the first two elements, ⊸⋈ # and make a list of this list, ∊ # and check whether this equals ↑ # any prefix of the input; ×´ # finally get the product to check if all are true. ``` [Answer] # [J](http://jsoftware.com/), ~~38~~ 12 bytes ``` 2{]E.~2+/\}: ``` Or ``` 2&}.-:2+/\}: ``` -26 bytes, thanks @Jonah [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/japjXfXqjLT1Y2qt/mtypSZn5CukKZhYKpgbKhgaGSgYWhoqGBsaKpgaGMEkjRVMFMwVDA0RfEugUgVDU6BCmBhQs4IRSOV/AA "J – Try It Online") [Answer] # [Standard ML (MLton)](http://www.mlton.org/), ~~51~~ ~~48~~ 45 bytes ``` fun$(x::y::z::L)=x+y=z andalso$(tl L)\| $_=1=1 ``` [Try it online!](https://tio.run/##K87N0c3NKcnP@/8/rTRPRaPCyqrSyqrKyspH07ZCu9K2SiExLyUxpzhfRaMkR8FHs0ZBJd7W0Nbwf1lijkJJUWmqgq2CikK0mY6CpY6CoamOgpFJLBdILg2oCSpprKNgoqMAVGJoAMRmsf8B "Standard ML (MLton) – Try It Online") -3 bytes thanks to Laikoni. -3 bytes using `tl` to recurse instead of pattern matching. [Answer] # [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~38~~ 37 bytes ``` \d+ $ ^((1+),(?=(1+),\2\3\b))+1+,1+$ ``` [Try it online!](https://tio.run/##NYyxDsIwEEP3@44iJZyH@i5pyVB15CciBAgGFgbE/4e0EpMtW@99nt/X@9YO4Xxt9aEyHOUSAjUirMue1arXe4xKBXVojSAMjiwTCphhSVLB3HcbwUI4iTyaOBJmkLIBSf5g2o8JJ5TeusI2i/MH "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation: ``` \d+ $* ``` Convert to unary. ``` ^((1+),(?=(1+),\2\3\b))+ ``` Repeatedly match a number, each time checking that the number two ahead is the sum of it and the next number. ``` 1+,1+$ ``` Match the final two numbers. Previous 38-byte version used .NET's ability to recapture an existing named or numbered group: ``` \d+ $* ^(1+),(1+)(,(?<2>\1(?<1>\2)))+$ ``` [Try it online!](https://tio.run/##NYwxCsMwFEP3f44U7FhD9P2d1FDSsZcwpYVmyJKh9P6uXegiCYmn9/bZj2c9udujlleQYZS7Y/Do4uCuF10Lm3Et6r0PQ60EoYhIMiODCWpiGUvrdQIzEUmkSSXCsICUDpj8QfsNM87ILbUL7S@RXw "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation: ``` \d+ $* ``` Convert to unary. ``` ^(1+),(1+) ``` Match two numbers `\1` and `\2`... ``` (,(?<2>\1(?<1>\2)))+$ ``` ... then repeatedly match numbers that are the sum of `\1` and `\2`, but recapture `\1` as `\2` and `\2` as the sum, so that each number has to be the sum of the previous two. [Answer] # APL+WIN, 26 bytes Prompts for input ``` (¯2+⍴v)=+/(¯2↓v)=1↓-2-/v←⎕ ``` [Try it online! Thanks to Dyalog Classic](https://tio.run/##RYzNCcJAEIXvU8U7KmFJZnaTuAcLEBRrCJGIEFAIBGwgelEEsQ4vVmAp28g6EcHTfPP@qkNrNseq3W9N3VZdt6tjuD5WyzDcLCkt1kpM4Xxq4uT9lCRcXv10nqTjE4a7MusxYtJek9qImqXYEIMhsMipoQIenEOcsvMo1ZMM7BmWGXkmqls4lGCmsSpw9J9wP7vADP7LOifjouUP "APL (Dyalog Classic) – Try It Online") [Answer] # [PowerShell Core](https://github.com/PowerShell/PowerShell), 53 bytes ``` !(3..($a=$args).length\|?{$a[--$_-2]+$a[$_-1]-$a[$_]}) ``` [Try it online!](https://tio.run/##fY9Bb4JAEIXv/IrRbCqku0RAbD2Ykhh7bVN7M8RQOmoNFcsuaRPkt@MABU1LuyGbCe/b994c4k9M5BajSIRxggVbT7OipzumqbNgyoJkIw0zwv1GbY93GQuWQrCVsP1rGmmwfFENfm4UuaZ5ugZ0uKd7usWBPpuDw8E1ODCVpGic9TGHCSEuMaMOeUTiTelhD@ma0ORYdLlDuwOmiBHhBFodal2jClkHkfwhtSU7gdqZut5S3T@Acg27XsWx/jWxyl3GF4gBR7iPk3kQbsXDyw5DBVn1jimUahZIJBa/DiTgK0yBrWo1QZlGin5csTV4DVtpy8fFLJUqfq/9fK82LM8iDUOUkp71eo2FwI9zQkv2n8kSSs9@mdoEgNjFb3sY8EFLzi/K/bJ5amp@p1VCruVacQI "PowerShell Core – Try It Online") Takes a list of numbers as parameter and returns a boolean [Answer] # C#, ~~114~~ 113 bytes ``` var a=args;int i=0,r=0;for(;i<a.Length-2;)if(int.Parse(a[i])+int.Parse(a[i+1])!=int.Parse(a[i+++2]))r=1;return r; ``` Program expects the list to be passed as a list of command line arguments, e.g.: ``` ./program 1 2 3 5 8 ``` Program uses C# v9 top-level statements feature, this is a full C# program. Unwrapped: ``` var a = args; int i = 0, r = 0; for (; i < a.Length - 2;) if (int.Parse(a[i]) + int.Parse(a[i + 1]) != int.Parse(a[i++ + 2])) r = 1; return r; ``` ]
[Question] [ The [Fibonacci sequence](https://en.wikipedia.org/wiki/Fibonacci_number) is a fairly well known thing around here. Heck, it even has its own tag. However, for all that, we sure like to stick to our roots of `1, 1, ...` (or is it `0, 1, ...`? We may never know...). In this challenge, the rules are the same, but instead of getting the `n`th item in the Fibonacci sequence, you will get the `n`th item in the Fibonacci-esque sequence starting with `x, y, ...`. # Input Three integers, in whatever order you want. `n` is the index (0 or 1 indexed) of term in the sequence for your output. `x` and `y` are the first two items in your current program run's Fibonacci sequence. # Output The `n`th term in the Fibonacci sequence starting with `x`, `y`. # Test Cases (0-indexed) ``` n x y out 5 0 0 0 6 0 1 8 6 1 1 13 2 5 5 10 10 2 2 178 3 3 10 23 13 2308 4261 1325165 0 0 1 0 1 0 1 1 ``` (1-indexed) ``` n x y out 6 0 0 0 7 0 1 8 7 1 1 13 3 5 5 10 11 2 2 178 4 3 10 23 14 2308 4261 1325165 1 0 1 0 2 0 1 1 ``` # Caveats Assume `0 <= x <= y`. Please note your input order (must be constant). [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes ``` +¡ạ ``` Takes x, y, and n (0-indexed) as separate command-line arguments, in that order. [Try it online!](https://tio.run/nexus/jelly#@699aOHDXQv///9v/N/Q4L8xAA "Jelly – TIO Nexus") ### How it works ``` +¡ạ Main link. Left argument: x. Right argument: y. Third argument: n ạ Yield abs(x - y) = y - x, the (-1)-th value of the Lucas sequence. +¡ Add the quicklink's left and right argument (initially x and y-x), replacing the right argument with the left one and the left argument with the result. Do this n times and return the final value of the left argument. ``` [Answer] # [CJam](https://sourceforge.net/p/cjam), ~~14~~ 9 bytes ``` l~{_@+}; ``` [Try it online!](https://tio.run/nexus/cjam#@59TVx3voF2rZf3/v5GCkYKhIQA "CJam – TIO Nexus") Input format is "x y n". I'm still a noob at this, so I'm 100% sure there are better ways to do this, but please instead of telling me "do this" try to only give me hints so that I can find the answer myself and get better. Thanks! [Answer] # [Python 2](https://docs.python.org/2/), 37 bytes ``` f=lambda x,y,n:n and f(y,x+y,n-1)or x ``` [Try it online!](https://tio.run/nexus/python2#@59mm5OYm5SSqFChU6mTZ5WnkJiXopCmUalToQ3k6xpq5hcpVPwvKMrMKwEKG@kY6RgaaP4HAA "Python 2 – TIO Nexus") 0-indexed, you may need to adjust the recursion limit for `n≥999` [Answer] # JavaScript (ES6), ~~27~~ 26 bytes Nothing fancy here, just a standard JS Fibonacci function with the initial values of 0 & 1 removed. ``` n=>g=(x,y)=>n--?g(y,x+y):x ``` --- ## Try it ``` f= n=>g=(x,y)=>n--?g(y,x+y):x o.value=f(i.value=13)(j.value=2308,k.value=4261) oninput=_=>o.value=f(+i.value)(+j.value,+k.value) ``` ``` {font-family:sans-serif;} input{margin:0 5px 0 0;width:50px;} #o{width:75px;} ``` ``` <label for=i>n: </label><input id=i type=number><label for=j>x: </label><input id=j type=number><label for=k>y: </label><input id=k type=number><label for=o>= </label><input id=o> ``` [Answer] ## Python 2, 40 bytes 0-indexed [Try it online](https://tio.run/nexus/python2#@5@nk6iTZJuZV1BaoqHJlVqRmqwOEkjSSdROslbXyuMqKMrMK1FI/P8/2tBAx0jHKBYA) ``` n,a,b=input() exec'a,b=b,a+b;'n print a ``` [Answer] # [Haskell](https://www.haskell.org/), 30 bytes ``` x#y=(f!!)where f=x:scanl(+)y f ``` [Try it online!](https://tio.run/nexus/haskell#Zc7NCsIwEATgu08xpR6ySCE/REXIwxRtsKBRWsHk6eMmXgzucb5h2Bz75ITvOnpfp2WCd/G0nsdwEztK8Pk@zgEOlwc2AIYB9UREj0QIJXwuc3hhCyE5lARbe/KPFGFf6diQ@iVlGrNslqC/1k5qNk2cVju0o6aM8i@moDb5Aw "Haskell – TIO Nexus") 0-indexed. Use as `(x#y)n`, e.g. `(0#1)5` for the fifth element of the original sequence. The most likely shortest way to get the Fibonacci sequence in Haskell is [`f=0:scanl(+)1f`](https://codegolf.stackexchange.com/a/89/56433), which defines an infinite list `f=[0,1,1,2,3,5,8,...]` containing the sequence. Replacing `0` and `1` with arguments `x` and `y` yields the custom sequence. `(f!!)` is then a function returning the nth element of `f`. [Answer] ## Mathematica, 36 bytes ``` LinearRecurrence[{1,1},{##2},{#+1}]& ``` input > > [n,x,y] > > > [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 40 bytes ``` $n,$x,$y=$args;2..$n\|%{$y=$x+($x=$y)};$y ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyVPR6VCR6XSViWxKL3Y2khPTyWvRrUaJFChraFSYatSqVlrrVL5//9/0/@G/w0B "PowerShell – Try It Online") [Answer] # [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 38 bytes ``` {({}[()]<(({}<>)<>{}<(<>{}<>)>)>)}{}{} ``` [Try it online!](https://tio.run/nexus/brain-flak#@1@tUV0braEZa6MBZNjYadrYASkNMGmnCYK11UD4/78xl6EBlzEA "Brain-Flak – TIO Nexus") ``` {({}[()]< >)} # For n .. 0 (({}<>)<> ) # Copy TOS to the other stack and add it to... {} # The second value <(<>{}<>)> # Copy what was TOS back {}{} # Pop the counter and the n+1th result ``` [Answer] # Ruby, 27 bytes ``` ->a,b,n{n.times{b=a+a=b};a} ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes ``` ;SḊµ¡I ``` [Try it online!](https://tio.run/nexus/jelly#@28d/HBH16GthxZ6/v//P9pIxyj2v6EhAA "Jelly – TIO Nexus") Explanation* ``` µ¡ - repeat n times (computes the n+1th and n+2th element): S - take the sum of the elements of the previous iteration (starting at (x,y)) ; - append to the end of the previous iteration Ḋ - remove the first element I - Take the difference of the n+1th and n+2th to get the n-th. ``` [Answer] # [TAESGL](https://github.com/tomdevs/taesgl), 4 bytes ``` ēB)Ė ``` 1-indexed [Interpreter](https://tomdevs.github.io/TAESGL/v/1.3.1/index.html?code=XHUwMTEzQilcdTAxMTY=&input=NyxbMSwxXQ==) Explanation Input taken as `n,[x,y]` ``` ēB)Ė AēB) get implicit input "A" Fibonacci numbers where "B" is [x,y] Ė pop the last item in the array ``` [Answer] # [Prolog (SWI)](http://www.swi-prolog.org), 77 bytes ``` f(N,Y,Z):-M is N-1,f(M,X,Y),Z is X+Y. l(N,A,B,X):-asserta(f(0,A,B)),f(N,X,_). ``` [Try it online!](https://tio.run/nexus/prolog-swi#JYy7DsMgDEX3fkVGrN4gDE1UdUufUzJDlipDkCplKv1/aojOcnx97RzVhICZLu3YfFIztYyoRngEwlwSfwz6sElrwBVeektK6/e3qKhMyYhQfni8See8qQ5GGAhy1IuxVHZn4VbdohPu1dnACo86ODhI8Nw3DtaZM062Z7xI/wE "Prolog (SWI) – TIO Nexus") Started off golfing [Leaky Nun's answer](https://codegolf.stackexchange.com/a/121135/69074) and arrived at something completely different. This one has a rule for `(Nᵗʰ, (N+1)ᵗʰ)` in terms of `((N-1)ᵗʰ, Nᵗʰ)` and uses [database management](http://www.swi-prolog.org/pldoc/man?section=db) to assert 0ᵗʰ and 1ˢᵗ elements at runtime. `f(N,X,Y)` means `Nᵗʰ` element is `X` and `(N+1)ᵗʰ` element is `Y`. [Answer] # R, 39 bytes ``` f=function(x,y,n)'if'(n,f(y,x+y,n-1),x) ``` A simple recursive function. Funnily enough this is shorter than anything I can come up with for the regular Fibonacci sequence (without built-ins), because this doesn't have to assign `1` to both `x` and `y` =P Calculates `n+1` numbers of the sequence, including the initial values. Each recursion is calculates with `n-1` and stopped when `n==0`. The lowest of the two numbers is then returned, giving back the `n`-th value. [Answer] # [Octave](https://www.gnu.org/software/octave/), 24 bytes ``` @(n,x)(x[0,1;1,1]^n)(1) ``` Input format: `n,[x,y]`. [Try it online!](https://tio.run/nexus/octave#NcvLCoAgFIThfU/R8hiDOMeUIILeQ2zpsrVvb3bbfTPwl3EbrbVtlxPVSJ2SA1eC@TiN0LQiAf1z2QxF4k3@5EdFCggP6ZAU@tgjefAN2Yd6t2DW2KN2AQ "Octave – TIO Nexus") [Answer] # [Prolog (SWI)](http://www.swi-prolog.org), 85 bytes ``` l(0,X,Y,X). l(1,X,Y,Y). l(N,X,Y,C):-M is N-1,P is N-2,l(M,X,Y,A),l(P,X,Y,B),C is A+B. ``` [Try it online!](https://tio.run/##JcwxDoMwDAXQvadgjNWfKA6CoRuEdgMxwgkqpEggGDg@OEZ/efa3vO1rWv/2OJfrSsZjwoyJ3CsZVs/qQR3pY/tiOYrBMsYHAcn02jYkHJUtIea6ebcuv63gJXIgr2oR5ws1S6I6oJJ0avYIkq8OJUrI4kfuBg "Prolog (SWI) – Try It Online") 0-indexed. [Answer] # x86 machine code, 7 bytes `EDX = x = fib[1]`, `EAX = y = fib[2]`, `RCX = n` (1-indexed) returns in EAX. Works in all 3 modes (16, 32, and 64). ``` 0000000000401070 <cfib>: 401070: eb .byte 0xeb # jmp rel8 consuming the 01 add opcode as a rel8 0000000000401071 <cfib.loop>: 401071: 01 d0 add eax,edx # loop entry point on first iteration, jumping over the ModRM byte of the ADD 401073: 92 xchg edx,eax 401074: e2 fb loop 401071 <cfib.loop> 401076: c3 ret ``` This "jumps" into the loop with machine code that decodes 2 different ways: with a `jmp +1` when falling into the loop from the top of the function, or with that `01` byte being an ADD opcode when the `loop` instruction jumps backwards. Equivalent to `jmp .entry` but with only 1 byte outside the loop instead of 2. (Credit to [@Ira Baxter](https://stackoverflow.com/questions/10765317/can-assembled-asm-code-result-in-more-than-a-single-possible-way-except-for-off/10766612#10766612) for pointing out the general idea of falling into a loop with 1 byte outside that consumes some loop bytes to do something different on the first iteration, e.g. the opcode for `cmp al, imm8` as a 1-byte encoding for a jump forward by 1. I got lucky that `01 add` could be consumed by jmp rel8 to skip a total of 2 bytes without needing a `66` prefix for `cmp ax, imm16` or being in 16-bit mode. 01 or 03 add didn't work well as a modrm for anything like `add r/m32, imm8`; we need to avoid a memory operand. Note that this trick is not* good for performance on some modern CPUs, e.g. AMD that caches instruction boundaries in L1i tags, and probably not newer Intel/AMD with uop caches.) Stripping labels lets objdump decode as the CPU would on the first pass: ``` cfib: 401070: eb 01 jmp 0x401073 # jmp rel8 = +1 401072: d0 .byte 0xd0 # jumped over 401073: 92 xchg edx,eax 401074: e2 fb loop 0x401071 401076: c3 ret ``` It's easy to see that the EDX input will be the EAX return value for ECX=1 (exit right away, `loop` is never taken so `add` never runs). Use `strace ./custom-fib 14 2308 4261` to see the full integer value passed to the `exit()` system call before truncation to an 8-bit exit status. In 32-bit mode, the same machine code is callable with GCC regparm(3) calling convention as `__attribute__((regparm(3))) unsigned custom_fib(unsigned y /eax/, unsigned x /edx/, unsigned n /ecx/);`, returning in EAX as usual. --- ## Without the 2-way decode hack: x86 machine code, 8 bytes 0-indexed `n` in RCX, `x` (`fib[0]`) in EAX, y (`fib[1]`) in EDX - note opposite arg order ``` 0000000000401070 <cfib>: 401070: e3 05 jrcxz 401077 <cfib.done> 0000000000401072 <cfib.loop>: 401072: 0f c1 c2 xadd edx,eax 401075: e2 fb loop 401072 <cfib.loop> 0000000000401077 <cfib.done>: 401077: c3 ret ``` This way shows off x86's [`xadd`](https://www.felixcloutier.com/x86/xadd) instruction, normally only used with a memory destination and a `lock` prefix to implement `fetch_add`. The reg,reg form of `xadd` decodes to only 3 uops on Intel Skylake, [same as `xchg reg,reg`](https://stackoverflow.com/questions/45766444/why-is-xchg-reg-reg-a-3-micro-op-instruction-on-modern-intel-architectures) (<https://uops.info/>). (The `loop` instruction is slow on Intel so this is hardly optimized for speed. If you want a speed-efficient asm implementation, unroll by 2 to remove the xchg as shown [in my SO answer](https://stackoverflow.com/questions/32659715/assembly-language-x86-how-to-create-a-loop-to-calculate-fibonacci-sequence/32661389#32661389) using clever loop setup to avoid excess branching for odd vs. even `n` for standard 0,1 Fibonacci.) [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 5 bytes ``` ⁽+dḞi ``` Takes input as `[x, y]` then `n`. [Try it online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwi4oG9K2ThuJ5pIiwiIiwiWzAsIDBdLCA1XG5bMCwgMV0sIDZcblsxLCAxXSwgNlxuWzUsIDVdLCAyXG5bMiwgMl0sIDEwXG5bMywgMTBdLCAzXG5bMjMwOCwgNDI2MV0sIDEzXG5bMCwgMV0sIDBcblswLCAxXSwgMSJd) Explanation: ``` Ḟ # Create an infinite list from the initial vector [x, y] from: d # a dyadic, ⁽ # single element lambda + # which adds its two arguments. i # Index into that list with the second input (n). ``` [Answer] # [Python 2](https://docs.python.org/2/), 112 bytes 1-indexed. ``` import itertools def f(x,y): while 1:yield x;x,y=y,x+y def g(x,y,n):return next(itertools.islice(f(x,y),n-1,n)) ``` [Try it online!](https://tio.run/nexus/python2#PcxBCsIwEIXhfU8xywRHMatCxNPYqQ6kkzKd0uT0MSq4fXzvb7ysWQ3YSC3ntA0TzTC7gtXHAY4XJ4IQK1OaoNz6fK9YTvXLnh@G4qOS7SogVMz9SxfeEj/I/WIo59Cpb6uyWL9eMeDo2xs "Python 2 – TIO Nexus") [Answer] # [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 36 bytes ``` ?sdsbsa[lddlb+sdsbla1-dsa1<c]dscxldp ``` [Try it online!](https://tio.run/nexus/dc#@29fnFKcVJwYnZOSkpOkDeLkJBrqphQnGtokx6YUJ1fkpBT8/29orGBkbGChYGJkZggA "dc – TIO Nexus") `0`-indexed. Input must be in the format `n x y`. [Answer] # PHP>=7.1, 55 Bytes ``` for([,$n,$x,$y]=$argv;$n--;$x=$y,$y=$t)$t=$x+$y;echo$x; ``` [Online Version](http://sandbox.onlinephpfunctions.com/code/3d0a076a75c2163d9f443a59f165aaf955d2a2af) # PHP>=7.1, 73 Bytes ``` for([,$n,$x,$y]=$argv,$r=[$x,$y];$i<$n;)$r[]=$r[+$i]+$r[++$i];echo$r[$n]; ``` [Online Version](http://sandbox.onlinephpfunctions.com/code/c1acd204195b92546d7b998c39234efb2e567aef) [Answer] # Common Lisp, 49 Bytes, 0-indexed ``` (defun fib(n x y)(if(= 0 n)x(fib(1- n)y(+ x y)))) ``` I'm a Lisp noob so any tips would be appreciated ;) ### Explanation: ``` (defun fib(n x y) \| Define a function taking 3 arguments (if(= 0 n)x \| If n = 0, return x (fib(1- n)y(+ x y)))) \| Otherwise, call fib with n-1, y, and x+y ``` [Answer] # br\\nfuck, ~~39~~ 29 bytes Thanks to @JoKing for -10! ``` ,<,<,[>[>+>+<<-]<[>+<-]>-]>>. ``` TIO won't work particularly well for this (or for any BF solution to a problem involving numbers). I strongly suggest @Timwi's [EsotericIDE](https://github.com/Timwi/EsotericIDE) (or implementing BF yourself). Takes `x`, then `y`, then `n`. 0-indexed. Assumes an unbounded or wrapping tape. ### Explanation ``` ,<,<, Take inputs. Tape: [n, y, x] [ While n: > [->+>+<<] Add y to x, copying it to the next cell along as well. Tape: [n, 0, x+y, y] < [>+<-] Move n over. Tape: [0, n, x+y, y] >- Decrement n. ] >>. End loop. Print cell 2 to the right (x for n == 0). ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), 29 bytes ``` f(n,x,y){n=n?f(n-1,y,x+y):x;} ``` [Try it online!](https://tio.run/##bdBNbsIwEAXgNTnFiIoqphMUJxWiTQMHqVgE5wdL7lA5prKFuHqNrbJAUXcz732bGZENQvgnSUKd2@5jNK08rY7b5DFR8hAi36eEFh27UE27sGQcHdoXx95tdfWSDHw1ktI4NHoQCOLYaFgu4/bD4JLM/gLoqK2SWXQENYxGm5NSaVSffI/wHHoEnrM7slNU/IPcFJUT9K0D69P5op0jxFPAIjgWK92ZsybIq@TqPS99UeYb/1qs@a/oVTOMPgtPqMVbfgM "C (gcc) – Try It Online") This implementation is 0-based. [Answer] # [MATL](https://github.com/lmendo/MATL), 7 bytes ``` :"wy+]x ``` Output is 0-based. Try it at [MATL Online!](https://matl.io/?code=%3A%22wy%2B%5Dx&inputs=10%0A2%0A2&version=19.11.0) ### Explanation Let the inputs be denoted `n` (index), `a`, `b` (initial terms). ``` :" % Implicitly input n. Do this n times % At this point in each iteration, the stack contains the two most % recently computed terms of the sequence, say s, t. In the first % iteration the stack is empty, but a, b will be implicitly input % by the next statement w % Swap. The stack contains t, s y % Duplicate from below. The stack contains t, s, t + % Add. The stack contains t, s+t. These are now the new two most % recently comnputed terms ] % End x % Delete (we have computed one term too many). Implicitly display ``` [Answer] # [Braingolf](https://github.com/gunnerwolf/braingolf), 15 bytes ``` VR<2-M[R!+v]R_; ``` `_;` is no longer needed on the latest version of Braingolf, however that's as of ~5 minutes ago. This could be 13 bytes by removing that. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes ``` `©GDŠ+}®@ ``` [Try it online!](https://tio.run/nexus/05ab1e#@59waKW7y9EF2rWH1jn8/x9trGNooGMSCwA "05AB1E – TIO Nexus") Explanation ``` ` # split inputs as separate to stack © # store n in register G # n-1 times do D # duplicate top of stack Š # move down 2 places on stack + # add top 2 values of stack } # end loop ®@ # get the value nth value from the bottom of stack ``` [Answer] # [Lua](https://www.lua.org), 44 bytes 0-Indexed ``` n,x,y=...for i=1,n do x,y=y,x+y end print(x) ``` [Try it online!](https://tio.run/nexus/lua#@5@nU6FTaaunp5eWX6SQaWuok6eQks8FEqvUqdCu5ErNS@EqKMrMK9Go0Pz//7@h8X8jYwOL/yZGZoYA "Lua – TIO Nexus") [Answer] # [Klein](https://github.com/Wheatwizard/Klein), 18 + 3 bytes This uses the `000` topology ``` :?\(:(+)$)1-+ ((/@ ``` Pass input in the form `x y n`. [Answer] # Axiom, ~~88~~ 57 bytes ``` f(k,x,y)==(repeat(k<=0=>break;c:=y;y:=x+y;x:=c;k:=k-1);x) ``` this would pass the test proposed (0 indexed) ``` (14) -> f(5,0,0) (14) 0 Type: NonNegativeInteger (15) -> f(6,0,1) (15) 8 Type: PositiveInteger (16) -> f(2,5,5) (16) 10 Type: PositiveInteger (17) -> f(10,2,2) (17) 178 Type: PositiveInteger (18) -> f(3,3,10) (18) 23 Type: PositiveInteger (19) -> f(13,2308,4261) (19) 1325165 Type: PositiveInteger ``` ]
[Question] [ Between the [kitten question](https://codegolf.stackexchange.com/questions/59029/the-kitten-command) and seeing [this question at U&L](https://unix.stackexchange.com/questions/233014/how-does-the-command-sed-1ghd-reverse-the-contents-of-a-file) about some `sed` magic, how about implementing [`tac`](http://linux.die.net/man/1/tac)? --- # Objective Implement a program that will reverse and print the lines in a file. --- # Input A file, provided as a name or via standard input --- # Output The lines, reversed, to standard out. --- # Scoring Bytes of source code. [Answer] ## GS2, 3 bytes ``` * + ``` The three bytes are, in order, split lines, reverse, and join lines. [Answer] # Perl, 11 bytes ``` $\=$_.$\}{ ``` Behaves exactly like `tac`. This code requires the `-p` switch, which I have counted as 1 byte. ### Test runs ``` $ echo -en 'a\nb' \| perl -pe'$\=$_.$\}{' \| xxd -g 1 0000000: 62 61 0a ba. $ echo -en 'a\nb\n' \| perl -pe'$\=$_.$\}{' \| xxd -g 1 0000000: 62 0a 61 0a b.a. ``` ### How it works As explained [here](https://codegolf.stackexchange.com/a/32884), the `-p` switch basically wraps `while (<>) { ... ; print }` around the program, so the source code is equivalent to ``` while(<>) { $\ = $_ . $\ } print ``` For each line of input, we prepend the current line (`$_`) to `$\` (initially undefined), updating the latter with the result. After all lines have been processed, `print` prints the value of the local variable `$_` (undefined in this scope), followed by the output record separator (`$\`). [Answer] # Pyth, 4 bytes ``` j_.z ``` `.z` is the input separated by lines as a list, `_` reverses it and `j` joins it by a character, which by default is `\n`. [Answer] # [FlogScript](https://esolangs.org/wiki/FlogScript), 2 bytes ``` )" ``` (Try it on [anarchy golf](http://golf.shinh.org/check.rb).) The `)` enables `--in-out-line-array` mode, and the rest of the program is `"`, reversing the array of lines. [Answer] # [Retina](https://github.com/mbuettner/retina), 7 bytes ``` !rm`.$ ``` With a single regex, Retina runs in Match mode. This normally just prints the number of matches, but with `!` we configure it to print the actual matches instead (separated by linefeeds). The actual regex is merely `.$`. `.` matches any line (potentially empty), because `.` can match any character except linefeeds. I'll get to the `$` in a minute. How do we make it print the matches in reverse? By making use of .NET's right-to-left matching mode, activated with the `r`. This means the regex engine starts at the end of the string when looking for matches and works backwards. Finally, the `m` makes the `$` match the end of a line* instead of the end of the string. Why do we even need that? The trouble is that `.` generates extraneous matches. Consider the regex substitution ``` s/a/$0x/ ``` applied to the input `baaababaa`. You'd think this would yield `baaaxbaxbaax`, but it actually gives you `baaaxxbaxxbaaxx`. Why? Because after matching `aaa` the engine's cursor is between the `a` and the `b`. Now it can't match any more `a`s, but `a` is also satisfied with an empty string. This means, after every single match you get another empty match. We don't want that here, because it would introduce additional empty lines, so we discard those extraneous matches (which are at the beginnings* of the lines, due to the right-to-left mode) by requiring that matches include the end of the line. [Answer] # Haskell, 34 bytes ``` main=interact$concat.reverse.lines ``` [edit] Saved one byte by replacing `unlines` with `concat`. [Answer] # CJam, 7 bytes ``` qN/W%N* ``` Reads stdin, prints to stdout. Explanation: ``` q Get input. N/ Split at newlines. W% Reverse list. N* Join with newlines. ``` [Answer] # Pyth, 5 bytes ``` jb_.z ``` This reverses the order of the lines with a simple split-reverse-join approach, but [not quite like tac](https://codegolf.stackexchange.com/questions/59239/implement-tac-print-lines-from-a-file-in-reverse/59249#comment142591_59239). [Try it online.](https://pyth.herokuapp.com/?code=jb_.z&input=a%0Ab%0Ac) [Answer] # Befunge-93, 17 bytes ``` ~:1+!#v_ >:#,_@>$ ``` Nothing fancy here; just put everything on the stack, then pop it off. [Answer] # Pure Bash (no external utilities), 56 ``` mapfile a for((i=${#a[@]};i--;));{ printf %s "${a[i]}" } ``` This is one of the few answers to do exact `tac` emulation, as asked about in [Dennis' comment](https://codegolf.stackexchange.com/questions/59239/implement-tac-print-lines-from-a-file-in-reverse/59274#comment142591_59239): ``` $ echo -en 'a\nb' \| ./tacemu.sh \| xxd -g 1 0000000: 62 61 0a ba. $ echo -en 'a\nb\n' \| ./tacemu.sh \| xxd -g 1 0000000: 62 0a 61 0a b.a. $ ``` [Answer] # Ruby, 16 bytes ``` puts [$<].reverse ``` [Answer] # Python 2, 52 bytes ``` import sys;print''.join(sys.stdin.readlines()[::-1]) ``` [Answer] ## sed, 9 bytes ``` 1!G;h;$!d ``` No upvote wanted, this is a famous sed one-liner. [Answer] ## Perl, 16 bytes ``` print reverse<> ``` [Answer] # Powershell, 41 bytes ``` $a=$args\|%{gc $_};[array]::Reverse($a);$a ``` Stores the content of a file line by line in `a`, reverses `a` and finally prints it. [Answer] # GolfScript, 7 bytes ``` n/-1%n ``` Online test [here](http://golfscript.apphb.com/?c=J2FiYwpkZWYKZ2hpJwoKbi8tMSVuKgo%3D&run=true). [Answer] # [Burlesque](http://mroman.ch/burlesque/), 6 bytes ``` ln<-uN ``` `ln` splits lines, `<-` reverses, `uN` joins lines and formats for raw output. [Answer] # Bash, ~~48~~ 43 characters (Inspired by [Digital Trauma](https://codegolf.stackexchange.com/users/11259/digital-trauma)'s [Bash answer](https://codegolf.stackexchange.com/a/59275). Upvotes for the idea should go to him.) ``` mapfile -c1 -C's=$2$s;set' printf %s "$2$s" ``` Sample run: ``` bash-4.3$ echo -en 'a\nb' \| bash tac.sh \| xxd -g 1 0000000: 62 61 0a ba. bash-4.3$ echo -en 'a\nb\n' \| bash tac.sh \| xxd -g 1 0000000: 62 0a 61 0a b.a. ``` [Answer] # JavaScript (SpiderMonkey Shell), 38 bytes ``` [...read(readline())].reverse().join`` ``` Pretty simple --- `read()` reads a file `readline()` reads a string from STDIN `[...str]` will split str into an array of chars `reverse()` will reverse the array `join``` will collpase the array into a string [Answer] # GNU Awk, 27 characters (Inspired by [Ed Morton](https://codegolf.stackexchange.com/users/45679/ed-morton)'s [GNU Awk answer](https://codegolf.stackexchange.com/a/59322). CW as I not intended to hijack his solution.) ``` {s=$0RT s}END{printf"%s",s} ``` Note that by changing `RT` → `RS` this becomes portable standard Awk but looses the ability to preserve the absence of the final newline. Sample run: ``` bash-4.3$ echo -en 'a\nb' \| awk '{s=$0RT s}END{printf"%s",s}' \| xxd -g 1 0000000: 62 61 0a ba. bash-4.3$ echo -en 'a\nb\n' \| awk '{s=$0RT s}END{printf"%s",s}' \| xxd -g 1 0000000: 62 0a 61 0a b.a. ``` [Answer] # C#, ~~179~~ 171 bytes ``` using B=System.Console;class A{static void Main(){var a=new System.Collections.Stack();string b;while((b=B.ReadLine())!=null)a.Push(b);foreach(var c in a)B.WriteLine(c);}} ``` Reads lines, placing them in a stack, and then writes them backwards. I would use Mathematica for this, but it has no sense of EOF. [Answer] # SNOBOL, 42 bytes ``` S S =INPUT CHAR(10) S :S(S) OUTPUT =S END ``` [Answer] # Gema, 25 characters ``` \n=@set{s;$0${s;}} \Z=$s ``` Sample run: ``` bash-4.3$ echo -en 'a\nb' \| gema '\n=@set{s;$0${s;}};\Z=$s' ba bash-4.3$ echo -en 'a\nb\n' \| gema '\n=@set{s;$0${s;}};\Z=$s' b a ``` [Answer] # [Hassium](http://HassiumLang.com), 90 Bytes 86 Bytes ``` use IO;func main(){c=File.readLines(args[0]);for(x=c.length-1;x>=0; println(c[x--]))0; ``` See expanded [here](http://HassiumLang.com/Hassium/index.php?code=0a2a15ed11c102ba90de2012c6078c09) [Answer] # sed, 7 bytes ``` G;h;$!d ``` This works for me (and it's the shortest solution elsewhere), but I don't really want to find out why. I just messed around with the famous 9-byte trick until I found this. I guess `G`ing the first line does nothing? [Answer] # JavaScript(Node.js), 91 Bytes ``` console.log(require('fs').readFileSync(process.argv[2])+"".split(d="\n").reverse().join(d)) ``` [Answer] # Bash + common utilities, 25 ``` tr \\n ^G\|rev\|tr ^G \\n\|rev ``` Here the `^G` is a literal `BEL` character. I'm assuming the input is only printable ascii. This `tr`ansforms the entire input to one line by replacing newlines with BELs, then `rev`erses that line, then `tr`ansforms back to multiline, then `rev`erses each line again, to get the desired output. [Answer] # MATLAB, 44 ``` @(x) strjoin(fliplr(strsplit(x,'\n')),'\n'); ``` Splits the string at new lines, flips the resulting array, then rejoins with new line characters. [Answer] # Julia, 65 bytes ``` open(s->print(join(reverse([l for l=readlines(s)]),"")),ARGS[1]) ``` This takes a file as a command line argument and prints its lines in reverse order. Trailing newlines are moved to the front, unlike `tac`, which is legit. Ungolfed: ``` function p(s::Stream) # Create a vector of the lines of the input stream L = [l for l in readlines(s)] # Reverse the vector and join it back into a string j = join(reverse(L), "") # Print the string to STDOUT print(j) end # Open the file specified in the first command line argument # and apply the function p to its contents open(p, ARGS[1]) ``` [Answer] # [Pip](http://github.com/dloscutoff/pip), 3 + 2 = 5 bytes Uses the `r` and `n` flags; reads from stdin. ``` RVg ``` The `r` flag reads stdin and stores it as a list of lines in `g` (which is normally a list of command-line arg*s). We then reverse that list, and it is auto-printed. The `n` flag causes lists to be output with newline as a separator. ]
[Question] [ A big part of radio communication is the [NATO Phonetic Alphabet](https://en.wikipedia.org/wiki/NATO_phonetic_alphabet), which encodes letters as words to make them easier to understand over comms. Your job, if you wish to accept it, is to print them one by one. You must print this exact string to stdout: ``` A: Alfa B: Bravo C: Charlie D: Delta E: Echo F: Foxtrot G: Golf H: Hotel I: India J: Juliet K: Kilo L: Lima M: Mike N: November O: Oscar P: Papa Q: Quebec R: Romeo S: Sierra T: Tango U: Uniform V: Victor W: Whiskey X: Xray Y: Yankee Z: Zulu ``` # Rules: * Your program takes no input * Standard loopholes are Disallowed. * If there are any builtins in your language that turn letters to their NATO equivelants, you may not use them (I'm looking at you Mathematica). * You may have trailing spaces and one trailing newline. [Answer] # [Python 2](https://docs.python.org/2/), ~~189~~ 186 bytes ``` i=65 for w in"lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split():print'%c: %c'%(i,i)+w;i+=1 ``` [Try it online!](https://tio.run/nexus/python2#Dc3BCoMwEIThe59iKIiKpdBDe7D4MGu61sUkK2vU@vQ25/mY/5Tu9bwMatgh8eoHgtGmGMm8MNgnghsV@kumCeoHaGKP@BHCmkmCeIUEgkwM3Tj0bFgcGWjOhHt20MDZsBmB4lcRJRcDxKUcHmWZ@MjZI48Tc75dr/dl9pKqup1NYioL16JwZVHJTepmf0vTPc7zDw) --- Previous: (this was cool, but I realised the simpler version could be made shorter by a byte) ``` w='' i=65 for c in"lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU": w+=c.lower() if'_'>c:print'%c: %c'%(i,i)+w;w='';i+=1 ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 76 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` “ṭṡl°ẠkWßġȮRẎ+wḋñȥạġ¢ƊḌ¬kạẠ¦WṡỊƒK⁹ç}⁶hm}Kñ£ɦ/lṇẊɠƓ}pƤ°⁸Ụ.g⁹Ġh9ṁ{f»ḲØAżj€⁾: Y ``` [Try it online!](https://tio.run/nexus/jelly#AZUAav//4oCc4bmt4bmhbMKw4bqga1fDn8ShyK5S4bqOK3fhuIvDscil4bqhxKHCosaK4biMwqxr4bqh4bqgwqZX4bmh4buKxpJL4oG5w6d94oG2aG19S8OxwqPJpi9s4bmH4bqKyaDGk31wxqTCsOKBuOG7pC5n4oG5xKBoOeG5gXtmwrvhuLLDmEHFvGrigqzigb46IFn//w "Jelly – TIO Nexus") ### How? Pretty much just dictionary values and compression. The code between `“` and `»` is just a compressed value that will form the string `"Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu"` by looking up all the words (with single space prefixes, except for `"Alfa"`) in Jelly's dictionary (except for `" Xray"` which is not in the dictionary, so the direct string value `" X"` and the dictionary entry `"ray"` are used instead). The rest of the code does the rest: ``` “...»ḲØAżj€⁾: Y - Main link: no arguments “...» - the string described above (really a list of characters) Ḳ - split at spaces ØA - alphabet yield - ['A','B','C', ...,'X','Y','Z'] ż - zip - makes a list of lists [['A'],['A','l','f','a']],[['B'],['B','r','a','v','o']], ...] j€ - join each with ⁾: - the string ": " Y - join with line feeds - implicit print ``` [Answer] ## [Retina](https://github.com/m-ender/retina), 156 bytes Byte count assumes ISO 8859-1 encoding. ``` AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu [A-Z] ¶$&: $& G`. ``` [Try it online!](https://tio.run/nexus/retina#DcpJDoJAEADAO6/wQLjpA7zhhvu@YkxssJEOM9OmmSHyMR/gx9A6V@OFKoOeQMX9HEQRDlBZGKY5j/hthW3EKhuzRTUxD4Kp@xc7I8Vz0rCgApdcoU5QVmUKsoYXbBwmmG5ZI@8IRWAP5skHQxmLPlJqWU45lQXWZ4H6AqZAjJ1y3jVsxzfv@/GDbssPvOjeaZof "Retina – TIO Nexus") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), ~~102~~ 98 bytes Saved 4 bytes thanks to Erik the Outgolfer ``` ”AlfaÐ†vo¼¯¤œ®È¨›trotŠˆƒ‹Š™ÈŸt Kilo´àma—……ÍÐ—Žêpa¼°«Äoµ†Çâgo¸šÉµ Whiskey Xrayµ‹nkeeâ¸lu”#vy¬„: «ì, ``` [Try it online!](https://tio.run/nexus/05ab1e#Fc4xCsJAEIXhqyzYegI7aw@g7RZRQ6IrMQbSbRE0FoJoWmUNIqJBLQwkos0Ma@Mt5iJxA6/74eNVJHdtt89xTVIFAt5wh6Pewg1jOJN8@Z7wtfrNvxuSpVYUpRjrwmcd2xXwRDXiJBOSJzNc1UiiP3iZcAM94IqRgNzAuMB0IKDQB1xCzrpDe@pYIet5PKx7OXYsC1Mo3Jm50whCyEjuW8wAWbOq/g "05AB1E – TIO Nexus") Explanation Uses dictionary compression for the words in 05AB1E's dictionary. Uses partial dictionary compression whenever possible for other words. Plain-text words where neither is possible. ``` # # split on spaces v # for each word y # push the word ¬ # get the first letter of the word „: # push the string ": " « # append this to the letter ì # prepend the result to the word , # print with newline ``` [Answer] # Ruby, 169 characters (Heavily based on [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)'s [Python 2](https://codegolf.stackexchange.com/a/112229) solution. If you like the idea, please upvote the original answer.) ``` i=?@ "LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu".scan(/.[a-z]+/){\|w\|puts i.succ!+": "+i+w.downcase} ``` Sample run: ``` bash-4.3$ ruby -e 'i=?@;"LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu".scan(/.[a-z]+/){\|w\|puts i.succ!+": "+i+w.downcase}' \| head A: Alfa B: Bravo C: Charlie D: Delta E: Echo F: Foxtrot G: Golf H: Hotel I: India J: Juliet ``` [Answer] # Java 7, ~~242~~ ~~225~~ ~~222~~ 217 bytes ``` void d(){char c=65;for(String s:"lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split(" "))System.out.println(c+": "+c+++s);} ``` Explanation: ``` void d(){ // Method char c = 65; // Starting character 'A' for(String s : "lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu" .split(" ")) // Loop over the word-parts System.out.println( // Print line with: c // The current character + ": " // + ": " + c++ + s // + the current character + word-part (and raise the character afterwards) ); // End of print line // End of loop (implicit / single-line body) } // End of method ``` Test code: [Try it here.](https://ideone.com/b0YOtR) ``` class M{ static void d(){char c=65;for(String s:"lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split(" "))System.out.println(c+": "+c+++s);} public static void main(String[] a){ d(); } } ``` [Answer] # Octave, ~~215~~ ~~210~~ 209 bytes ~~Saved 5 bytes thanks to Luis Mendo.~~ I saved 4 bytes thanks to Luis Mendo, but changing the approach help me save one more ``` fprintf('%s: %s%s\n',[k=num2cell(65:90);k;regexp('lfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu','[A-Z]','split')]{:}) ``` [Try it online!](https://tio.run/nexus/octave#DcrJasMwEADQX@nFyIYUSqGFOvTQfd/3pDlM1FE8aKQxIykklH67m9O7vMH1SjG72lSp3apSlb6jGU39YSxh1yJzvb/XHuw0Yz9WXOCqrw07OFZYykkHyoSnyBnObCfnssoq@ULYXUpGvoo/BNdlU/INsdxSgDvyeC9LDHPUh2RBH6GHp4JztM8SUF4IVeEV4kLeIjnR8E42i350lDyuPxXWXxA94qRwMSMzPdqezDamnimbZvbb/jXD8A8) ~~If I got rid of the spaces, I'd save 25 bytes, but then~~ I'd have to use a regex. The regex itself would cost quite a few bytes, and it would also remove the capital letter of all words, leaving me with the words `lfa, ravo` etc. I would therefore have to concatenate the new strings with the leading characters. All this costs bytes. Old explanation: ``` fprintf('%s: %s\n', % Print a string with the format "str: str\n" num2cell(65:90) % Create a cell array with the numbers 65 - 90, one in each cell strsplit('Alfa ... % Split the string on the default delimiter: space [num2cell();strsplit()] % Concatenate cell arrays, leaving us with % {'A', 'B' % 'Alfa', 'Bravo'} [...]{:} % Convert the cell array to a comma-delimited vector % 'A', 'Alfa', 'B', 'Bravo' ... ``` [Answer] ## PHP, ~~202~~ ~~227~~ ~~196~~ 187 bytes Thanks to [Dewi Morgan](https://codegolf.stackexchange.com/users/41364/dewi-morgan) for saving 9 bytes ``` echo preg_replace('/([A-Z])[a-z]+/',"$1: $0\n",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu); ``` <https://repl.it/GMkH/1> --- Older versions Thanks to [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) and [insertusernamehere](https://codegolf.stackexchange.com/users/41859/insertusernamehere) for saving 31 bytes! ``` foreach(preg_split('/\B(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu)as$k)echo"$k[0]: $k\n"; ``` <https://eval.in/749541> Thanks to [insertusernamehere](https://codegolf.stackexchange.com/users/41859/insertusernamehere) for noticing the output was wrong with the previous version. ``` $a=preg_split('/(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu,-1,PREG_SPLIT_NO_EMPTY);foreach($a as $k)echo "$k[0]: $k\n"; ``` <https://repl.it/GKS8/3> ``` $a=preg_split('/(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);foreach($a as $k)echo"$k[0]: $k\n"; ``` <https://repl.it/GKS8/2> [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 178 bytes ``` "Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu"ṇ₁{hw": "w?ẉ}ᵐ ``` [Try it online!](https://tio.run/nexus/brachylog2#DcpLUsJQEAXQrdzKMpxQgAiI/L86a0LHdOUlbXVeAhTFACaUMzfjQHcTNhI941MHTRcRWkaloh2TOWE8svOEThgrnvTgTT266iL01LNDP9sJ4bn4nx4DcYoXSQlDSRgjLTndsmGch2SY0AdhWvCWQ8w0ZcVc2IywoOxdscwkUkuxktCrYR1LnvARG6MjXilLmPFWuCKofm736@UU74MHBPtG9ft5rr6/6voP "Brachylog – TIO Nexus") ### Explanation ``` "…"ṇ₁ Split the string on spaces { }ᵐ Map on each word: hw Write the first letter ": "w Write ": " ?ẉ Write the word followed by a new line ``` [Answer] # PHP, ~~188~~ ~~186~~ ~~180~~ 174 bytes no trailing spaces, one leading newline ``` <?=preg_filter("#[A-Z]#"," $0: $0",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu); ``` simply replaces all uppercase letters in the compressed string with `<newline><letter><colon><space><letter>` [Answer] # [Python 2](https://docs.python.org/2/), ~~186~~ 182 bytes ``` print''.join('\n%s: '%c('['>c)+c for c in'AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu') ``` [Try it online!](https://tio.run/nexus/python2#Dc1JDoJAEADAr3AhI5r4AA8m7vu@L5d2bKRlmCbNQOT1yL2SqlIh65Rqf5lsQz2tn3U85etmQz1UVwct7YUsnvbIqp4JoS9Q8CACMYRDNA5GOuIx/5ywm7AJp@zQzOybYJ7XxC3I8JISWFGMay4weaFsMg2yhRR2Ob5Q7zlBPhCKwBHsh0@W6jI5k3Ysl4iyGMurQHkDGyPec5OroKr@ "Python 2 – TIO Nexus") [Answer] # C (MinGW, Clang), 218 bytes Thanks to @gastropner!* ``` i;f(){char s[]="lfa:ravo:harlie:elta:cho:oxtrot:olf:otel:ndia:uliet:ilo:ima:ike:ovember:scar:apa:uebec:omeo:ierra:ango:niform:ictor:hiskey:ray:ankee:ulu";for(i=64;++i<91;)printf("%c: %c%s\n",i,i,strtok(i^65?0:s,":"));} ``` [Try it online!](https://tio.run/##Dc/RasMwDAXQ93xFMAQS2sEGW2HXK/2QbgPVUxYRxyq2W1ZKvz2T9CYddFF4CpHS77qKH/vhHibKbTl@7V0cCZmuCptEYXCshDAp9K9mrdA4QitHpB8hXIxUSFTIQpCZoVdeTpxRAmXQ2QifOEAXNsM5EyxWkWTUvEBC1YxJysw3i73Zcma2sxfnDfSy3736zUY@3l/8cM6S6ti7LqDtQlc@k9uKdam56tzL9@7t8IyydXDD4B@r6XYhSf3Q3JvWyj71zWP9Bw) # C, ~~259~~ 236 bytes ``` i;f(){chars="lfa\0ravo\0harlie\0elta\0cho\0oxtrot\0olf\0otel\0ndia\0uliet\0ilo\0ima\0ike\0ovember\0scar\0apa\0uebec\0omeo\0ierra\0ango\0niform\0ictor\0hiskey\0ray\0ankee\0ulu";for(i=64;++i<91;s+=strlen(s)+1)printf("%c: %c%s\n",i,i,s);} ``` [Try it online!](https://tio.run/##FY/disMgEEbv8xQhENDNFiwsC1s3b@KNdcdmiD9FbWkpffbsF4URz3dkRne4OLdtrL2QL7fY8lHnIXhrVLH3bBRIYDKKQgNzC1B@tJIbzuBRGgWj0h8jvcEE5wCJIwCveJnvFM9UjKrOotrrbtKZHKJIu0qlgNl0wSWxzyUCupZhL1xXeu7DPHdjJdrb3AYNS/D8/aWniX9/jrpOc20lUBJVTkd5LZyaF8PoTv3oxmrS8MnYVer3hqiPlpOQ3avrsfB33b23fw) [Answer] # Gema, 168 characters ``` \A=@subst{?<J>=\?: \$0\\n;AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu}@end ``` Sample run: ``` bash-4.3$ gema '\A=@subst{?<J>=\?: \$0\\n;AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu}@end' \| head A: Alfa B: Bravo C: Charlie D: Delta E: Echo F: Foxtrot G: Golf H: Hotel I: India J: Juliet ``` [Answer] # x86 Assembly, 512 bytes Compiled with NASM and tested with QEMU. To boot you need to put a 2 byte boot signature at the end of the bootsector (510 bytes into the file) so I lost 317 bytes filling the compiled code with zeros. This is my first golf so I have to apologize for any gigantic errors. ``` [org 7c00h] ;So NASM can change the labels into memory locations correctly. cld ;Tells lodsb to look forward in memory mov bh, 65 ;Moves the ASCII value of A into the BH register mov si, NATO ;Moves the first byte of NATO into the si register call print ;Call the 'print' subroutine jmp $ ;Loops forever print: mov ah, 0eh ;Moves the hex value 0E into the AH register. Tells interrupt 10h that we want subfucntion 0E lodsb ;Load a byte of SI into AL and increments a register (DL i think) that tells it the offset to look at cmp al, 3 ;Compares the AL register that now has a byte from our string to ASCII value 3 (Enf Of Text) je R ;If AL == 3 then jump to R cmp al, 0 ;Comapre AL to ASCII 0 (NULL) je newWord ;If AL == 0 hump to newWord int 10h ;Execute interrupt 10h Subfunction 0Eh (stored in AH register) which prints character value in AL jmp print ;Jump to print newWord: mov al, 10 ;Move ASCII 10 (New Line) into AL int 10h ;Print character mov al, 13 ;Move ASCII 13 (Carriage Return) into AL int 10h ;Print character mov al, bh ;Move BH (which has our starting letter) into AL int 10h ;Print Character mov al, 58 ;Move ASCII 58 (:) into AL int 10h ;Print Character mov al, 32 ;Move ASCII 32 (Space) into AL int 10h ;Print Character mov al, bh ;Move BH into AL int 10h ;Print Character inc bh ;Increments BH by one (BH++) jmp print ;Jump to print R: ret ;Returns from a subroutine ;Below defines bytes (db) of our string to print. I used 0 as word seperators and 3 to end the string. NATO: db 0,"lfa",0,"ravo",0,"harlie",0,"elta",0,"cho",0,"oxtrot",0,"olf",0,"otel",0,"ndia",0,"uliet",0,"ilo",0,"ima",0,"ike",0,"ovember",0,"scar",0,"apa",0,"uebec",0,"omeo",0,"ierra",0,"ango",0,"niform",0,"ictor",0,"hiskey",0,"ray",0,"ankee",0,"ulu",3 times 0200h - 2 - ($ - $$) db 0 ;Zerofill the file with upto 510 bytes (This is where all my bytes are) dw 0AA55H ;Write the bootsignature ``` ## Output This is what the above code outputs. As you can see A: Alfa* is missing and that is because the prompt is 25 lines tall... ![Above codes output](https://i.stack.imgur.com/pA47p.png) To prove I printed A: Alfa I replaced `0,"ulu"` with `32,"Z: Zulu"` so that Zulu is one on the same line as Yankee. ![Changed code](https://i.stack.imgur.com/2xaqf.png) I would appreciate it if someone told me if I would be able to subtract the 317 bytes of zerofill from my code so it would be 195 bytes. Also if this is even valid because the output won't fit on the screen. [Answer] # [Bash](https://www.gnu.org/software/bash/), ~~224~~ ~~205~~ ~~188~~ 180 bytes Thanks to [Digital Trauma](https://codegolf.stackexchange.com/users/11259/digital-trauma) for removing 17 bytes, and [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) for 8 bytes. ``` set {A..Z} for i in lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu;{ echo $1: $1$i;shift;} ``` [Try it online!](https://tio.run/nexus/bash#Fc0xDsIwDIXhnVO8gbkSK524BpsbHGI1iZGTVlRVz17M4Mm/3nc27tgfw/A8LlENAqnIkWC0KhJZFgbnTghJod9u2qE5Qjtn1JcQFk86JCukEGRm6MplYkMLZKCPJzxxgBb2hs0IVN@KKi4WSOgOJ2kzb85u/pyZfXYZd/Cfvd7uflcZW5LYx@M8fw "Bash – TIO Nexus") [Answer] # [Python 2](https://docs.python.org/2/), 198 bytes ``` for x in'Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu'.split():print x[0]+': '+x ``` [Try it online!](https://tio.run/nexus/python2#Dc67bsJAEAXQX7mdiZAQNV2AQIDwDK@AKAZnjEde71jjNTJfb9yf4jSJGmqIjz5dQhgaPRWjlMwJY8wuEL7iVDHROpgGTNUl@NbADjP/L4R51cqAhTjFj@SEpWSMlT45v7NhXcZk2FBB2FZ85xg7zVnxK2xG2JN/KA5e2kaOo8Sh7ZxSKTN@4Wz0wh/5jBmXylVRryychM7HoDDxAfW1f@tGA0Tdumne "Python 2 – TIO Nexus") Not exciting or clever. Just loops through the list and prints the first letter then ': ' then the whole word. [Answer] # PHP, 184 bytes 179 bytes 178 ``` <?=preg_filter('/(.)[a-z]+/',"$1: $0 ",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu); ``` saved a single byte by using preg\_filter instead of preg\_replace. --- Original answer 184 bytes 179 bytes ``` for($c=A;$s=[lfa,ravo,harlie,elta,cho,oxtrot,olf,otel,ndia,uliet,ilo,ima,ike,ovember,scar,apa,uebec,omeo,ierra,ango,niform,ictor,hiskey,ray,ankee,ulu][+$i++];$c++)echo"$c: $c$s "; ``` uses the fact that its sorted to generate the first char on the fly. 5 bytes saved by @Titus. [Answer] # [SOGL](https://github.com/dzaima/SOGL), 91 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md) ``` ╗D↕«∙φā¡75↔TI.½!γΜΧ…¡%<F┼0h╔κy\|▓@TņV≈%⁹cr_σy░mgļΕžΕ⅝ »τ{M╔\|«▼↔»aΓ²⁹┘′⅓G…└g↔bFΞ‽‘θ{KUtƧ: ooo ``` Explanation: ``` ...‘θ{KUtƧ: ooo that gibberish is a compressed string ...‘ push the compressed string of the words θ split on spaces { for each K pop the 1st letter off & push it U uppercase it t output in newline a copy of the letter Ƨ: o append ": " o append the alphabet letter o append the rest of the word ``` [Answer] ## [GNU sed](https://www.gnu.org/software/sed/), 165 bytes This script is based on the [Retina answer](https://codegolf.stackexchange.com/a/112209/59010) by Martin Ender. ``` s/$/AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu/ s/[A-Z]/\n&: &/g s/.// ``` [Try it online!](https://tio.run/nexus/sed#Dcq5EoIwEADQ3q@wcOg0vR3e932iFgsusEOSdZaEka9H2zevKVVHhTqFgUDFwxxEE45QOxgnOU/464TdlHU6Y4d6bt8EC/8vbkmaV2RgTQVuuEITo2zLBGQHH9h7jDE5sEE@EorACWzGZ0spi7lQ4liuOZUF1jeB@g62QIy89qpVqkfYjV7qaYN@O1DZH3pKNc0P) Explanation: ``` s/$/AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu/ # generate the alphabet words in concatenated form s/[A-Z]/\n&: &/g # prepend '\nUL: ' before each upper-case letter (UL), getting the needed format s/.// # delete the leading newline, plus implicit printing at the end ``` [Answer] # [Bash](https://www.gnu.org/software/bash/), 184 bytes ``` printf '%c: %s ' {Alfa,Bravo,Charlie,Delta,Echo,Foxtrot,Golf,Hotel,India,Juliet,Kilo,Lima,Mike,November,Oscar,Papa,Quebec,Romeo,Sierra,Tango,Uniform,Victor,Whiskey,Xray,Yankee,Zulu}{,} ``` [Try it online!](https://tio.run/nexus/bash#DcrLUoNAEAXQvV/BJsXmfoE7ExM1T6N5aHadSRO6GKapZqBCUXw7etZnrExCzJJ04p6TSf2UJv2LzwhTo1Yxy8m8MF7ZR8Lc5YqFPqJpxJv6DO8a2eMj3ISwbP5nxEq8Yi0lYSMFY6stl1c27GpHhk@qCPuGr@zwpSUrvoXNCAcKd8UxSKZW4iQuquGcS11whx@jDr8UCmZcGt8MPYZx/AM "Bash – TIO Nexus") [Answer] ## Lua, ~~278~~ 260 bytes Thanks again to [Manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) for saving 18 bytes! ``` function f(w)print(w.sub(w,0,1)..": "..w)end f"Alfa"f"Bravo"f"Charlie"f"Delta"f"Echo"f"Foxtrot"f"Golf"f"Hotel"f"India"f"Juliet"f"Kilo"f"Lima"f"Mike"f"November"f"Oscar"f"Papa"f"Quebec"f"Romeo"f"Sierra"f"Tango"f"Uniform"f"Victor"f"Whiskey"f"Xray"f"Yankee"f"Zulu" ``` [Try it online](https://tio.run/nexus/lua#FY27bsMwDEX3fkWgyQYCoV27NU3fr7RJ@tpkhaoJy2JAS3Hz9Q45nQNeXnIKJfmMlGahGus9Y8rVaIfSVOP8fH5RW2suZ8basYa0OwvmKgZnglmwO5DwunUcEcSWELMmN77V4Jb@M1MWu6MYBPeUIQof0g5177FIT/MnjFp4xl7HL9jptVc6QN8Ai74N3ilXbq8L7wUa8CIf1IMW1wjMmmxc@tPBNmEg7sU@0WfS7leLQwdHsW92ih@XOtBHvyUWM00n) --- Older versions ``` a={"Alfa","Bravo","Charlie","Delta","Echo","Foxtrot","Golf","Hotel","India","Juliet","Kilo","Lima","Mike","November","Oscar","Papa","Quebec","Romeo","Sierra","Tango","Uniform","Victor","Whiskey","Xray","Yankee","Zulu"} for i=1,26 do print(a[i].sub(a[i],0,1) .. ": " .. a[i]) end ``` <https://repl.it/GK8J> First time doing Lua, do probably can golf more, but thought I'd add it as an answer anyways. [Answer] # [Lua](https://www.lua.org), 177 bytes ``` print(("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"):gsub('%u',"\n%1: %1"):sub(2)) ``` [Try it online!](https://tio.run/nexus/lua#Fcq5DoJAEADQXzEkREhstKTzvu/b2Aw4wIRlhwy7RL4esX15TSGkjec5QxXDSKDicQqiCCeoDEyjlGf8NcJmzipesEG11B@ClW2LWZPiDeWwpQx3XGEeouzLCOQABRwthhidOEc@E4rABXTCV00xS36jyLDcUyozrB8C9RN0hviyyjp@kJQ29Lqu7fact3b7Qcftt/rHge83zQ8 "Lua – TIO Nexus") Without trailing newline, 180 bytes: ``` io.write(("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"):gsub('%u',"\n%1: %1"):sub(2)) ``` Explanation ``` str = "AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu" str = str:gsub('%u',"\n%1: %1") -- returns "\nA: Alfa...". %u matches uppercase letters, %1 returns matched letter in this case. str = str:sub(2) -- remove added newline in the beginning print(str) -- native print command ``` It uses Lua's string.gsub substitution function to pattern match the uppercase letters. The letters are then replaced with the requested format (plus the letters themselves). Newlines are also added on the same pass. The sub-function at the end just trims out newline from the beginning and also works nicely to hide the second return value of gsub, which would have been the amount of replacements. [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~187~~ 185 bytes ``` 0..25\|%{($a=[char]($_+65))+": $a"+(-split'lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu')[$_]} ``` [Try it online!](https://tio.run/nexus/powershell#Dc3RCoJAEIXhVznERooUEdRF0JNIyLSNObjryLhJUT277fX5OP@y3@0Ox@/6Uzi61L4juxauqU7HsqxWZzhaVcV2GoOkTWgJRrMioyAMDongO4W@kmmChhaaOGC4C@GZSYIEhUSC9AydOd7YMHky0JgJ39hDI2fDZgQaHopBWrUI8UkNnUw9v3P2nceeOd8@N2XtmutvWf4 "PowerShell – TIO Nexus") Loops from `0` to `25`, each iteration forming `$a` of the corresponding capital `char`. Then string-concatenated with `: $a` (i.e., the colon-space-letter). Then that string is string-concatenated with an string that's formed by indexing into an array created by `-split`ting the phonetic string on spaces. Each of those 26 strings is left on the pipeline, and an implicit `Write-Output` happens at program completion, inserting a newline between elements. Saved two bytes thanks to @Matt. [Answer] # C, ~~216~~ ~~215~~ 212 bytes ``` i=64,l;f(){for(chars="lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU";++i<91;printf("%c: %c%.s%c\n",i,i,l,s,s[l]+32),s+=l+1)for(l=0;s[++l]>90;);} ``` [Try it online!](https://tio.run/nexus/c-gcc#FY9RS8MwFEbf@ytKodAuQTYVYcYKQeqTEijzYcw9ZNmtvfQ2GUlahLHfXivf03k655uxenrkJNqivLbOF6bTfhWqjFrp9aQWIqyBojSdcr/Ru52jdxfhw55RjoSwQ1I4SOxrN8FwgiYY3eiLHOEEb24AheC91PZHWVwEn2iiazoMPey93mvbQz3SVyYYw5ftRlw82tgWWW6e09zkd6uQm2@bcVxGPPBwoCN7uC95YBWxTfnfTNVahANjdHzdrkUpbkkyOTyng0ZblOk1SdPlnkhu8/wH "C (gcc) – TIO Nexus") A detailed, human readable, well commented and perfectly valid (no compiler warnings) version of the program can be found below: ``` #include <stdio.h> int main() { // Uppercase characters designate the last character of a word chars="lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU"; int i = 64; // Consecutive character int l; // Word length // Loop `i` from A to Z; Shift `s` with word length // `s` always points to the beginning of a word for( ; ++i < 91; s += l + 1 ) { // Increment `l` until you reach the next capital letter for( l = 0; s[++l] > 90 ;); // Print the current character, the word without it's last letter // and the last letter lowercased printf( "%c: %c%.s%c\n", i, i, l, s, s[l]+32 ); } } ``` [Answer] # JavaScript ES6, 216 187 184 180 174 bytes ``` "AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".replace(/[A-Z]/g,` $&: $&`).trim() ``` Saved a byte thanks to Neil. Saved 5 bytes thanks to ETHproductions. ``` console.log("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".replace(/[A-Z]/g,` $&: $&`).trim()); ``` # [Japt](https://github.com/ETHproductions/japt), 127 bytes ``` `AlfaBŸvoC•r¦eDeltaE®oFoxÉ•GolfHÇUI˜iaJªietKiloL‹aMikeNovem¼rOs¯rPapaQue¼cRo´oSi€ŸTÂ UnifŽmVÅ¡rW–skeyXŸyY„keeZªu`r"%A"" $&: $& ``` [Try it online!](https://tio.run/nexus/japt#AZsAZP//YEFsZmFCwp92b0PClXLCpmVEZWx0YUXCrm9Gb3jDicKVR29sZkjDh1VJwphpYUrCqmlldEtpbG9MwothTWlrZU5vdmVtwrxyT3PCr3JQYXBhUXVlwrxjUm/CtG9TacKAwp9Uw4IKVW5pZsKObVbDhcKhclfClnNrZXlYwp95WcKEa2VlWsKqdWByIiVBIiIKJCY6ICQm//8teA "Japt – TIO Nexus") Saved 2 bytes thanks to obarakon. [Answer] # PHP, ~~175~~ ~~171~~ ~~164~~ 162 bytes Note: no longer requires compressed file, uses IBM-850 encoding. ``` for($l=A;$c=LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu[$i++];)echo$c<a?" $l: ".$l++:"",$c\|~▀; ``` Run like this: ``` php -nr 'for($l=A;$c=LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu[$i++];)echo$c<a?" $l: ".$l++:"",$c\|~▀;';echo ``` # Explanation Prints every character individually (lowercased by OR with a space). If an uppercase character is encountered, it first prints a string of the form "\nA: A". # Tweaks * Saved 4 bytes by using another compression strategy * Saved 7 bytes by using a different delimiter (to combine assignment of `$l` with explode param), and not preventing a leading newline * Saved 2 bytes with a new method [Answer] # Japt, ~~216~~ 214 bytes ``` `A: Alfa B: Bvo C: Cr¦e D: Delta E: E®o F: FoxÉ G: Golf H: HÇU I: Iia J: Jªiet K: Kilo L: La M: Mike N: Novem¼r O: Os¯r P: Papa Q: Que¼c R: Ro´o S: Si T: TÂ U: Unifm V: VÅ¡r W: Wskey X: Xy Y: Ykee Z: Zªu ``` Explaination: There is most likely a much better way to do it, but since i'm new I don't know it. I basically compressed the string with Oc" and put that string to be decompressed using Od" If someone wants to help me save bytes by using something different from line breaks, I'd be happy to learn! edit: Saved 2 bytes using ` instead of Od" [Answer] ## Pyke, 89 bytes ``` .d⻵㡺ᐒଆຳ뼙΋ÒΗ䊊繎ㅨڨǔᯍⰬᐓ❤ᄵ㤉ተ᤬䆰髨⨈性dc Fl5DhRJ": ``` [Answer] # Qbasic, 383 bytes Not impressive, but for what it's worth: ``` dim a(1to 26)as string a(1)="lfa a(2)="ravo a(3)="harlie a(4)="elta a(5)="cho a(6)="oxtrot a(7)="olf a(8)="otel a(9)="ndia a(10)="uliet a(11)="ilo a(12)="ima a(13)="ike a(14)="ovember a(15)="scar a(16)="apa a(17)="uebec a(18)="omeo a(19)="ierra a(20)="ango a(21)="niform a(22)="ictor a(23)="hiskey a(24)="ray a(25)="ankee a(26)="ulu for i=1to 26 ?chr$(i+64);": ";chr$(i+64);a(i) next ``` [Answer] # [///](https://esolangs.org/wiki////), 220 bytes ``` /;/: /A;Alfa B;Bravo C;Charlie D;Delta E;Echo F;Foxtrot G;Golf H;Hotel I;India J;Juliet K;Kilo L;Lima M;Mike N;November O;Oscar P;Papa Q;Quebec R;Romeo S;Sierra T;Tango U;Uniform V;Victor W;Whiskey X;Xray Y;Yankee Z;Zulu ``` [Try it online!](https://tio.run/nexus/slashes#Dcs5coNAEAXQ/J/CNyD3j7Tv@66shRszxUC7WoPKOj32y1@XMfv8yHrsxULQZ9/lZRhwUIrHoBhyqDEJRhzlpWHMsf0mt4QJJxYLTDm1pBEzzpqvIJhz3v6/hAUXIRqWXIZasOIqVIo11/bS@qGODTfPXBxbbuVHsOOu1Yfm2HNvtRoOPAR1Fxx5lObbcOKpCYV5jTPPIU/muPBShmelb1x5dXnjxps0lSruvLex7bo/ "/// – TIO Nexus") -20 bytes thanks to @ETHproductions. ]
[Question] [ # or: Build a vertical quine Inspired by [Take a stand against long lines](https://codegolf.stackexchange.com/q/124259/9365). Your task is to build a vertical quine with as short a line length as possible. ## Scoring Shortest line length (excluding newlines) wins, with [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") criteria as a tie-breaker. Line length is determined as the longest line in your program excluding the line break character. For example: ``` $_= Q. P ``` has a line length of 3 and a byte count of 8, whilst: ``` Q $ _ P ``` Has a line length of 1 and a byte count of 7 (assuming no trailing newline). ## Rules Quines must meet the [community definition of a quine](https://codegolf.meta.stackexchange.com/a/4878/9365). [Standard loopholes](https://codegolf.meta.stackexchange.com/q/1061/9365) are forbidden. [Answer] # [Lenguage](http://esolangs.org/wiki/Lenguage), line length 0, ≈ 1.01 × 10805 bytes The source code consists of > > 10124204951141713202533972929121310016060433092338061822344361345785088607872212687519180665846846689047959498775873817205954910072327976407177053174071436371843670134990737172675632938993247496933911137703773908536875512359091727633452506044935740750830240213878294804481182083555147915724921824921475110508228264569693355158523956426011218344830576542194309867719995259333487662608933990607888012376767799159279952780093033761421596267435996052643805835600325453580090964941176722519904997142820547696122795384058768166716813179490118821654787005844786013890425692181280317909786461426684986082270532414940905922244777135016193088362341771414388821075092853157152933099269703875111747946164773211049512395358715902962437487134522781505709420586981997748912591875626029183292826655753251235587052422561943 > > > linefeeds, which encodes the brainfuck program that follows. ``` >>++++++++>+++>+++>+>+>+>+>+>+>+>+++>+>+>+>+>+>+>+>+>+++>+>+>+>+>+>+>+>+>++++++++>++++>++++++++>++++>+++++++>++>+++>+>+++>++>+++>+++>+>+>+>+>+>+>+>+>++++>++++>+++++++>+>++++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++++>+>+>+>+>+>+>+>+>+>+>++++++++>++++>+++++++>+++++++>+>+>+++>+>+>+>++++++++>+++>+++++++>+>+++>+>+++>+>+++>+>++++++++>++++>++++++++>++++>++++++++>++++>++++>+>+++>+++>++>+++++++>+++++++>+>+>+>++++++++>+++>+>++++++++>++++>+>+++>++>+++++++>++>+++++++>++++>++++>++++++++>+++>++++++++>+++>+++>+>++++>++++>++>+++++++>+++>+++>++++++++>++++>+>+++>++>+++++++>++++>++++>+++++++>+++>+++>+++>+++>++++++++>++++>++++>+>+++>+>+++>++>+++++++>+++++++ [ [->+>+<<] >>>>[<<[->+<]>>[-<<+>>]>] <<[-[->+<]+>]+++ [[->>+<<]<]< ] +>+>+>+ [>]+++>++ [ [<]++++++++++.[-] >[-]>[-]>[-]>[-] <+[<<++++++++>>->+>-[<]<] ++++++++>++++++++>+++++++>> ] ``` The source code is mostly identical to [@jimmy23013's radiation-softened Lenguage quine](https://codegolf.stackexchange.com/a/73729/12012), minus the `.` at the end, with `++++++++++.[-]` replacing `.` to print linefeeds instead of null bytes, and the corresponding changes to the data section on line 1. [Answer] # JavaScript, line length 1, ~~960~~ ~~956~~ 928 bytes ``` [ t , r , u , e , f , a , l , s ] = ! 0 + [ ! 1 ] ; [ , n , d , , q , i ] = t . a + t V = [ ] [ f + i + n + d ] ; [ , , , c , , , o , , _ , , , , , y , z ] = V + 0 F = V [ E = c + o + n + s + t + r + u + c + t + o + r ] P = ( 1 + e + 2 + 3 - 4 + t ) [ 2 ] f = F ( r + e + t + u + r + n + _ + a + t + o + ( 0 + { } ) [ 3 ] ) ( ) ( 3 * 4 + [ ] [ E ] [ n + a + ( 0 [ E ] + 0 ) [ 9 + 2 ] + e ] ) [ 1 ] F ( a , a + l + e + r + t + y + a + P + q + P + a + P + q + z ) ` [ t , r , u , e , f , a , l , s ] = ! 0 + [ ! 1 ] ; [ , n , d , , q , i ] = t . a + t V = [ ] [ f + i + n + d ] ; [ , , , c , , , o , , _ , , , , , y , z ] = V + 0 F = V [ E = c + o + n + s + t + r + u + c + t + o + r ] P = ( 1 + e + 2 + 3 - 4 + t ) [ 2 ] f = F ( r + e + t + u + r + n + _ + a + t + o + ( 0 + { } ) [ 3 ] ) ( ) ( 3 * 4 + [ ] [ E ] [ n + a + ( 0 [ E ] + 0 ) [ 9 + 2 ] + e ] ) [ 1 ] F ( a , a + l + e + r + t + y + a + P + q + P + a + P + q + z ) ` ``` More readable version which also happens to be a quine (extraneous newlines removed): ``` [t,r,u,e,f,a,l,s]=!0+[!1];[,n,d,,q,i]=t.a+t V=[][f+i+n+d];[,,,c,,,o,,_,,,,,y,z]=V+0 F=V[E=c+o+n+s+t+r+u+c+t+o+r] P=(1+e+2+3-4+t)[2] f=F(r+e+t+u+r+n+_+a+t+o+(0+{})[3])()(34+[][E][n+a+(0[E]+0)[9+2]+e])[1] F(a,a+l+e+r+t+y+a+P+q+P+a+P+q+z)` [t,r,u,e,f,a,l,s]=!0+[!1];[,n,d,,q,i]=t.a+t V=[][f+i+n+d];[,,,c,,,o,,_,,,,,y,z]=V+0 F=V[E=c+o+n+s+t+r+u+c+t+o+r] P=(1+e+2+3-4+t)[2] f=F(r+e+t+u+r+n+_+a+t+o+(0+{})[3])()(34+[][E][n+a+(0[E]+0)[9+2]+e])[1] F(a,a+l+e+r+t+y+a+P+q+P+a+P+q+z)` ``` ### Explanation Whew. Settle in for a ride here, because this is gonna be a treacherous journey... I spent a long time trying to figure out how to solve this challenge with length 1—no built-ins (directly, anyway), keywords, or even arrow functions—before realizing that it is easily possible with [JSF\\\](http://www.jsfuck.com/), which can evaluate any JavaScript code while avoiding any multi-byte tokens. But a JSF solution would easily be thousands of bytes long, if not tens or hundreds of thousands. Thanksfully, we aren't limited to just `()[]+!`—we have all of ASCII at our disposal! I decided to start by golfing the essential building blocks of JSF—the characters that can be built up into strings to "unlock more features," so to speak. We can't use strings directly to get characters, as that would require lines of length 3. So instead, we steal a trick from JSF, getting a few chars from literals that can be built up with single-byte tokens: ``` JSF** Used here Value Chars unlocked !![] !0 true true ![] !1 false fals [][[]] t.a undefined ndi ``` From these we can expand outward, starting with `[].find`, which is a Function object. Converting this to a string `function find() { ...` gives us access to `c`, `o`, space (`_`), and parentheses (`y` and `z`). Perhaps more importantly, we now have access to its `constructor`, the `Function` function—which, inceptional as it may sound, gives us the ability to execute code by building a string, passing it to `Function()`, and then calling the function generated. I should probably mention the overall method used by the program itself. As of 2015, JavaScript has this really cool feature called "[tagged templates](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals)," which not only allows unescaped newlines in strings, but also lets us call a function with a string literal directly (in a way; `myFunc`abc`;` is roughly equivalent to `myFunc(["abc"])`). If we put the function call as the last thing in the program, the general structure will look like this: ``` code;func`code;func` ``` All `func` has to do then is output its argument, followed by a backtick, then its argument again, and a second backtick. Assuming we have the argument in `a` and a backtick stored in `f`, we can accomplish this with the code `alert(a+f+a+f)`. However, at the moment, we are missing `+` and the backtick itself. `+` (stored in `P`) isn't hard; we steal another trick from JSF, building the string `1e23`, converting to a number, then back to a string, giving `"1e+23"`. Getting a backtick is a bit more complicated. At first, I tried obtaining `String.fromCharCode`, but finding a `C` turned out to be nearly as difficult. Fortunately, `atob` is easy enough to obtain (`Function("return atob")()`; `b` is generated from `0+{}`, which gives `[object Object]`) and can give any ASCII char, if a proper magic string is found. A short script gave me `12A` as one of the options, which can conveniently be found in `12Array` (a bit shorter to generate, thanks to `[].constructor[n+a+m+e]`; `m` is found in `0 .constructor+0`: `"function Number() { ..."`). Finally, we stick everything together. We assign the backtick to variable `f`, but since we can't use it directly in the function string, we instead set variable `q` to the letter `f` and use that instead. This makes our final string `a+l+e+r+t+y+a+P+q+P+a+P+q+z`, or `"alert(a+f+a+f)"`. We then feed this to `Function()`, feed the our finished code to the result, and voila, we have a JavaScript quine with no more than one char per line! --- My head feels terrible at the moment, so please inquire about any mistakes I've made or things I've missed in this explanation, and I'll get back to you after I've had some rest... [Answer] # [Haskell](https://www.haskell.org/), line length 6, ~~400~~ ~~343~~ 336 bytes ``` {main= putStr $s++(s >>=(++ ":\n") .show) ++ "[]}"; s='{': 'm': 'a': 'i': 'n': '=': '\n': 'p': 'u': 't': 'S': 't': 'r': '\n': '$': 's': '+': '+': '(': 's': '\n': '>': '>': '=': '(': '+': '+': '\n': '"': ':': '\\': 'n': '"': ')': '\n': '.': 's': 'h': 'o': 'w': ')': '\n': '+': '+': '\n': '"': '[': ']': '}': '"': ';': '\n': 's': '=': []} ``` [Try it online!](https://tio.run/##bdA9CoQwEAXgfo4RBJWAB1DiJSzVwmIhsv7hKBbi2eO@yE5g2eZj8vIIQ2zH79cwOHeOXT8ZWvat2laKWOuEqSxNojWpvJlUShnb@UgJQd1eqiA28RnnFI@gAz2YgAGNHxewgw1UMq2hEwEGWkgkezqlYOQ6tJ@OArk/N7KLD9NQyuRhC2Zw/HT@PlyDFlySFaHD390@3@PcDQ "Haskell – Try It Online") I'm not aware of a way around `putStr`, thus the line length of 6. The outer curly braces allow to get rid of the otherwerwise required indention after a newline within a single declaration. [Answer] # [><>](https://esolangs.org/wiki/Fish), 22 bytes, line length 1 ``` / v o a o ^ } - d : " ``` [Try it online!](https://tio.run/##S8sszvj/X5@rjCufKxGI47hquXS5UrisuJS4/v8HAA "><> – Try It Online") -6 bytes thanks to [Emigna](https://codegolf.stackexchange.com/users/47066/emigna). [Answer] # [CJam](https://sourceforge.net/p/cjam), line length 1, ~~16~~ 13 bytes ``` " _ p " _ p ``` [Try it online!](https://tio.run/##S85KzP3/X4krnquAS4kLTP3/DwA "CJam – Try It Online") It's a small miracle that inserting newlines into the ~~standard quine `{"_~"}_~`~~ even shorter standard quine `"_p"␊_p` does the right thing. (Thanks, Martin!) The trailing newline is necessary. ## Explanation (with • as newline) ``` "•_•p•" Push that string. •• Do nothing. _ Duplicate the string. • Do nothing. p Pop it and print it with quotes and a newline: "•_•p•"• • Do nothing. ``` On termination, what's left on the stack is printed (`•_•p•`), yielding total output `"•_•p•"••_•p•`. [Answer] # [Haskell](https://www.haskell.org/) + CPP, line length 2, ~~705~~ 237 bytes ``` m\ a\ i\ n\ =\ p\ u\ t\ S\ t\ r\ $\ (\ :\ "\ \\ \\ \\ n\ "\ )\ =\ <\ <\ s\ +\ +\ s\ h\ o\ w\ \ s\ ;\ s\ =\ "\ m\ a\ i\ n\ =\ p\ u\ t\ S\ t\ r\ $\ (\ :\ \\ "\ \\ \\ \\ \\ \\ \\ n\ \\ "\ )\ =\ <\ <\ s\ +\ +\ s\ h\ o\ w\ \ s\ ;\ s\ =\ "\ ``` [Try it online!](https://tio.run/##nY0xCsJQFAT7PYWIhUG8QGIqLxCwsZjmE9SE/CTiN3h7X@SBoJ0Iw7JbLNOE1J1iNOtRQC0aUImuaEJ3dPC8oRVaoxwtEW8Gn5lfdk5CG@dVGjSiB1r4LDxLv/yu49v4qeZfu9mzPsdwSbY97qtqBg "Haskell – Try It Online") Using the flag `-CPP` which enables the C pre-processor allows us to use a backslash at the end of a line to continue it on the next line. The actual code is `main=putStr$(:"\\\n")=<<s++show s;s="<data>"`. Edit: A casual -468 bytes thanks to [Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%c3%98rjan-johansen)! [Answer] # Rust, line length: 5, bytes: ~~301~~ 299 [Try it online](https://play.rust-lang.org/?gist=73e5bd7828dead1a2c11c81db45c348b&version=stable) Despite how it looks, this isn't an esoteric programming language, there is just a lot of format line noise. Vertical length of 5 was chosen to be able to use `print`. I don't think there is a way to print that would have shorter vertical length, declaring C functions uses `extern` keyword, `stdout` is 6 bytes long, `write` is 5 bytes long, `no_main` is 7 bytes long (main is usually a function ;)). ``` fn main (){ let t=( r#"fn main (){ let t=("# ,r#") ; print !( r#"{} r#"{ }"{} ,r#"{ }"{}, r#"{ }"{} {}{}{ }{ }""#, r#" ,t.0, t.0, '#', t.1, '#', t.2, '#', t.1, '#', t.2, '}' )"# ) ; print !( r#"{} r#"{ }"{} ,r#"{ }"{}, r#"{ }"{} {}{}{ }{ }"# ,t.0, t.0, '#', t.1, '#', t.2, '#', t.1, '#', t.2, '}' )} ``` [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), Line length: 1, Byte count: 43 ``` 2 " D 3 4 « ç ¶ ì ý Ô " D 3 4 « ç ¶ ì ý Ô ``` [Try it online!](https://tio.run/##MzBNTDJM/f/fiEuJy4XLmMuE69BqrsPLuQ5t4zq8huvwXq7DU/DIcP3/DwA "05AB1E – Try It Online") [Answer] # [Japt](https://github.com/ETHproductions/japt), line length 1, 20 bytes Based off the [standard Japt quine by ETHproductions](https://codegolf.stackexchange.com/a/71932/59487). ``` " i Q ² " i Q ² ``` [Try it here!](https://ethproductions.github.io/japt/?v=master&code=IgppClEKIAqyCiIKaQpRCiAKsgo=&input=) [Answer] # JavaScript (ES6), line length 3, 17 bytes ``` f= _=> `f= ${f }` ``` [Answer] # [Red](http://www.red-lang.org), line-length: 10, 49 bytes ``` s: [prin [ "s:" mold s "do s" ]] do s ``` [Try it online!](https://tio.run/##K0pN@R@UmqIQHfu/2EohuqAoM08hmksBCJSKrZTAjNz8nBSFYohYSr5CsRJXbKwCiPH/PwA "Red – Try It Online") This in fact is a [Rebol](https://rosettacode.org/wiki/Quine#REBOL) quine Explanation: Red/Rebol's `mold` follows the coding style of putting 4 spaces offset. ``` s: [prin [ ; s is a block; print the following: "s:" ; literal "s:" mold s ; the representation of the block itself - all between [] "do s" ; literal "do s" ]] do s ; evaluate the block ``` [Answer] # [RProgN](https://github.com/TehFlaminTaco/Reverse-Programmer-Notation), 3 bytes, line length 1 ``` 0 0 ``` [Try it online!](https://tio.run/nexus/rprogn#@2/AZfD/PwA "RProgN – TIO Nexus") A copy of Dennis' answer [here](https://codegolf.stackexchange.com/a/103262/76162) (go upvote him too) This is a conforms to our [current definition](https://codegolf.meta.stackexchange.com/questions/4877/what-counts-as-a-proper-quine/4878#4878) of a proper quine, as the first 0 encodes the second 0 and vice-versa. [Answer] # [RProgN 2](https://github.com/TehFlaminTaco/RProgN-2), L = 1, B = 15 bytes ``` « Ø . ` - S ` . ``` This is equivilent to the program: ``` «Ø.` -S` . ``` ## Breakdown `«` first pushes a function representing implicitly the rest of the program to the stack, and then continues execution. `Ø.` appends an empty string to the function, which stringifies it. This will always stringify like the equivilent program, due to newlines being no-ops. ``\n-` Removes all newlines from the string, now looking like `«Ø.`=S`.`. `S` then converts it to a stack of single characters, and ``\n.` joins the stack by newlines, returning the expected program. [Try it online!](https://tio.run/##Kyooyk/P0zX6///Qaq7DM7j0uBK4dLmCgaTe//8A "RProgN 2 – Try It Online") [Answer] # [Underload](https://github.com/catseye/stringie), line length 1, 20 bytes ``` ( : a S S ) : a S S ``` [Try it online!](https://tio.run/##K81LSS3KyU9M@f9fg8uKK5ErGAg14az//wE "Underload – Try It Online") This is just the standard Underload quine with newlines appended. Requires an implementation like the TIO one which ignores unknown command characters. The part in `()` is a string literal put on the stack, `:` duplicates it, `a` wraps the top stack entry in parentheses, and `S` prints. [Answer] # [Perl 5](https://www.perl.org/), 259 bytes ``` $ _ = p . r . i . n . t . q { ' $ _ = p . r . i . n . t . q { ' , & { I . " X 0 y h ~ " ^ " E O 0 y " . x } ( $ _ , 6 , - 1 ) , ' } ; & { I . " X 0 o k h ~ " . ( Y \| p ) ^ " E O 0 \| f s o " } ' } ; & { I . " X 0 o k h ~ " . ( Y \| p ) ^ " E O 0 \| f s o " } ``` [Try it online!](https://tio.run/##pY6xDgFREEX78xkvYm2yNhQ0olSotDRUhBB2l4JYfPpzIgrRKBQnM3Nn7s0Uy2rXi5EGC4YU5FSykb2cpOQKyY@DhIymdewcmNLhwpq7/VxGTFQeasH9mRutV15GX9p0Sa2J@uAr5cD2nZPrmVH7QfqRWbPi6FXQ@6c/xic "Perl 5 – Try It Online") [Verification](https://tio.run/##7VFNCwFRFN37Fa9JhjJigcVkaWFlS52IMRrh@Czk468/rzMpJQsbUbM5vXfvPefc2xmPdom1cZSsTMDY@GAeHIItcA1WwK1wJqRwL9yAZ7iCD/9TUkopgwV9O2p5YA@sgicwAW@qDIRtsKsWjs2pBjxRjuAVLD7cnWBDGIA1sKR36uXGwjd2K3D@5FiRYB@86JbSyw6u7nbYiehJ@RsW5mKWk3qYy2VJ/X5S63i7yAL7o8AOkQmi0No7 "Bash – Try It Online"). [Answer] # Javascript (ES6 REPL), full-program, line-length: 3, byte-count: 31 ``` ( f= _=> `( f= ${f } ) ()` ) () ``` This is a port of @kamoroso94's answer to a self-contained full program. If anybody finds a way to strip off some bytes without adding more to the line-length feel free to comment :) [Answer] # [Pip](https://github.com/dloscutoff/pip), line length 1, 35 bytes ``` V Y " [ ` V Y ` y ] . C : 3 . 4 " ``` [Try it online!](https://tio.run/##K8gs@P@fK4wrkkuJK5orAcxK4KrkiuXS43LmsuIyBtImQLn//wE "Pip – Try It Online") Based on the shortest known Pip quine, `V Y"`V Y`.RPy"`. The main difficulty in squishing it to line length 1 is `RP`, which can't be split over two lines. But in this case, all `RP` (repr) does is wrap the string in double quotes, which we can do directly. Here's an explanation based on a horizontal version: ``` V Y"[`V Y`y].C:3. 4" Y" " Yank this string into the variable y V and eval it The code that is eval'd: [ ] Build a list containing: `V Y` this Pattern object (used for regex, but here useful as a string-like object that doesn't need double quotes) y y, the whole string 3. 4 Concatenate 3 and 4 to make 34 (since the 2-digit number won't work in the vertical version) C: Convert to ASCII character (: forces the precedence lower than .) . Concatenate the " to the end of each list element The resulting list is printed, concatenated together, with a trailing newline ``` [Answer] # [Befunge-98](https://pythonhosted.org/PyFunge/), 41 bytes ``` ^ @ , , a - 1 * 5 7 \| # ! a # : , ^ $ " ``` [Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//@P43Lg0gHCRC5dLkMuLS5TLnOuGi4FLmUuRaCYMpcVUC6OS4VL6f9/AA "Befunge-98 (PyFunge) – Try It Online") Really just a normal quine turned sideways, with some extra stuff to print newlines. ]
[Question] [ Given an integer N perform the following steps: (using 9 as an example). 1. Receive input N. (`9`) 2. Convert N from base10 to base2. (`1001`) 3. Increase every bit by 1. (`2112`) 4. Treat the result as base3 and convert it back to base10. (`68`) 5. Return/Output the result. --- ## Input May be received in any reasonable number format. You only need to handle cases where N > 0. --- ## Output Either return as a number or string, or print to `stdout`. --- ## Rules * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest code in bytes wins. * Default loopholes are forbidden. --- ## Test Cases ``` 1 -> 2 2 -> 7 5 -> 23 9 -> 68 10 -> 70 20 -> 211 1235 -> 150623 93825 -> 114252161 ``` [Answer] # [Python 2](https://docs.python.org/2/), 31 bytes ``` f=lambda n:n and 3f(n/2)+n%2+1 ``` [Try it online!](https://tio.run/##FYxBCoMwFAXX9hRvEzT1l5ofAlVo75IioYI@RXTR06fpYhYzi9m@x2el5pyec1zeYwQHInKEv6aGd7UtjbYup3UHMRFOoIIg6AWuK1Jw6v/BPzQMl2rbJx6oTThxe8H0Zw2DhoIytDb/AA "Python 2 – Try It Online") [Answer] # [JavaScript (Node.js)](https://nodejs.org), 23 bytes ``` f=x=>x&&x%2+1+3f(x>>1) ``` [Try it online!](https://tio.run/##JcVBDkAwEADAu1f0QnYVUY60n/ACQWVFulKN9PcVcZk55me@F09XqB2vW0pWR21iUcS8k0r2pYVojMJk2QPpdhA0qvZLSsyEWNjdfG7NyTtQJSwQ/jaBp@DJ7dAjDukF "JavaScript (Node.js) – Try It Online") [Answer] # [Java (JDK 10)](http://jdk.java.net/), 44 bytes ``` long n(long x){return x<1?0:x%2+1+3n(x/2);} ``` [Try it online!](https://tio.run/##fY3LDoIwEEX3fMXExKS1irbERAXjD@jKpXFRBUkRCoGiGMK311ofC2Nc3UzuuWcSfuGjJDzrY8qrCjZcyNbRaS5jkMhGg9syUnUpoQnoarJo@oxQ4g0kasYM@512AIr6kIojVIorE5dchJAZE9qqUsh4t@e4NRRYPWSwBBld7YGwb4tTXj6/iSX1QQTUYyYIwbYF2N4qFWVuXiu3MEqFMlcigUlv2HsZvon04/7RPNaUedM1/s/MvRl7Q53T6Ts "Java (JDK 10) – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes ``` B‘ḅ3 ``` [Try it online!](https://tio.run/##y0rNyan8/9/pUcOMhztajf///28JAA "Jelly – Try It Online") [Answer] # [J](http://jsoftware.com/), 7 bytes ``` 3#.1+#: ``` [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/jZX1DLWVrf5rcilwpSZn5CsopCkZKGTqGRlA@WkKhkbGpjC2pbGFkSnXfwA "J – Try It Online") Thanks Galen Ivanov for -4 bytes! I really need to improve my J golfing skill... [Answer] # [R](https://www.r-project.org/), ~~55~~ 43 bytes ``` function(n)(n%/%2^(x=0:log2(n))%%2+1)%%3^x ``` [Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNPUyNPVV/VKE6jwtbAKic/3QgopKmqaqRtqKmqpWocV/E/TcPS2MLIVPM/AA "R – Try It Online") Uses the standard base conversion trick in R, increments, and then uses a dot product with powers of `3` to convert back to an integer. Thanks to [@user2390246](https://codegolf.stackexchange.com/users/66252/user2390246) for dropping 12 bytes! [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes ``` b€>3β ``` [Try it online!](https://tio.run/##MzBNTDJM/f8/6VHTGjvjc5v@/zcyAAA "05AB1E – Try It Online") ``` b binary €> increment each 3β base 3 ``` --- # [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes ``` 2в>3β ``` [Try it online!](https://tio.run/##MzBNTDJM/f/f6MImO@Nzm4AMAwA "05AB1E – Try It Online") [Answer] # Java 10, ~~81~~ 52 bytes (Base conversion) ``` n->n.toString(n,2).chars().reduce(0,(r,c)->r3+c-47) ``` [Try it online.](https://tio.run/##hY7BTsMwDIbvfQprJ4e2EW2ZxlS2J9h22RFxCGk2srXOlKSbEOqzl7QFDggJKdEv279/fydxFempOveyFs7BVmj6iAA0eWUPQirYDSVAbegIEjeDECtDrws/vB0QrKCndE3cm723mo5ISc64fBPWIeNWVa1UeJ@gTSRL1/auiGX6sGB9GYWAS/taawnOCx/kanQFTaDAKer5RbCJYECDJtwidRsLHDEADsbiiKdXWQn6KSvyIHHMxinA/t151XDTen4JkR4bTlyiZvEsmX1l/PbUP@l/TKb9LC/mG/afa1k85t@2Lur6Tw) -29 bytes thanks to @Holger. Explanation:* ``` n->{ // Method with Long as both parameter and return-type n.toString(n,2) // Convert the input to a Base-2 String .chars().reduce(0,(r,c)-> // Loop over its digits as bytes r3+c-47) // Multiply the current result by 3, and add the digit + 1 // (which is equal to increasing each digit by 1, // and then converting from Base-3 to Base-10) ``` --- # Java 10, ~~171~~ ~~167~~ ~~151~~ ~~150~~ 149 bytes (Sequence) ``` n->{int t=31-n.numberOfLeadingZeros(n);return a(t+1)+b(n-(1<<t));};int a(int n){return--n<1?n+2:3a(n)+1;}int b(int n){return n<1?0:n+3b(n/=2)+n2;} ``` -16 bytes thanks to @musicman523, changing `(int)Math.pow(2,t)` to `(1<<t)`. -1 byte thanks to @Holger, changing `(int)(Math.log(n)/Math.log(2))` to `31-n.numberOfLeadingZeros(n)`. [Try it online.](https://tio.run/##hY9RS8MwEMff@ymOPSWLraZF0KXVZ0Hnw94UH9IuG5nrdaTpREo/e710Q1AEIclxd7//5f47fdTxbv0@VnvdtvCkLfYRgEVv3EZXBpYhnQpQsQcqb40D5IqqA106S0AoYMT4rg@ULzIZY4JdXRr3vHk0em1x@2Jc0zLSOeM7h6CZF5KLkmHMZJ57ztWgglyz8CLvT2AcYy7vUaSLbK5JL6QaAlD@xCBQVwsU2ZxGXhYpFzhP1TCqiDY8dOXeVtB67SkcG7uGmoyylXe02uub5ieTwT3UZAbNx5SwySfApnHTf7aQCmwus5SCEHxqAqw@W2/qpOl8cqCJntUJJhWzXMwuZucRv5n99/A/Oie9TLNr/h90m92kZ2qIhvEL) Explanation: ``` n->{ // Method with Integer as both parameter and return-type int t=31-n.numberOfLeadingZeros(n); // 2_log(n) return a(t+1) // Return A060816(2_log(n)+1) +b(n-(1<<t));} // + A005836(n-2^2_log(n)) // A060816: a(n) = 3a(n-1) + 1; a(0)=1, a(1)=2 int a(int n){return--n<1?n+2:3a(n)+1;} // A005836: a(n+1) = 3a(floor(n/2)) + n - 2floor(n/2). int b(int n){return n<1?0:n+3b(n/=2)+n2;} ``` When we look at the sequence: ``` 2, 7,8, 22,23,25,26, 67,68,70,71,76,77,79,80, 202,203,205,206,211,212,214,215,229,230,232,233,238,239,241,242, ... ``` We can see multiple subsequences: ``` A053645(n): 0, 0,1, 0,1,2,3, 0,1,2,3,4,5,6,7, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14, ... A060816(A053645(n)): 2, 7,7, 22,22,22,22, 67,67,67,67,67,67,67,67, 202,202,202,202,202,202,202,202,202,202,202,202,202,202,202, ... A005836(A053645(n)+1) 0, 0,1, 0,1,3,4, 0,1,3,4,9,10,12,13, 0,1,3,4,9,10,12,13,27,28,30,31,36,37,39,40, ... ``` So the sequence being asked is: ``` A060816(A053645(n)) + A005836(A053645(n)+1) ``` --- I suck at finding patterns, so I'm proud of what I found above.. Having said that, @user202729 found [a better and shorter approach in Java](https://codegolf.stackexchange.com/a/161625/52210) within a few minutes.. :'( [Answer] # [APL (Dyalog)](https://www.dyalog.com/), 10 bytes ``` 3⊥1+2⊥⍣¯1⊢ ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R2wTjR11LDbWNgOSj3sWH1hs@6loElFAw5EpTMAJiUyC2VAAShgYgEQMA "APL (Dyalog Unicode) – Try It Online") ``` 2⊥⍣¯1 binary 1+ go guess 3⊥ base 3 ``` [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes ``` ḃ+₁ᵐ~ḃ₃ ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@GOZu1HTY0Pt06oAzIfNTX//29oZGz6PwoA "Brachylog – Try It Online") ### Explanation Not that you really need one, but… ``` ḃ To binary +₁ᵐ Map increment ~ḃ₃ From ternary ``` [Answer] # [Ruby](https://www.ruby-lang.org/), 27 bytes ``` f=->x{x>0?x%2+1+3f[x/2]:0} ``` [Try it online!](https://tio.run/##NYtBCsIwFET3/xQBcWOtZiYmVsF4kJCFisGlSIVI27NHpHH3ePPm9b5@Skmn1uche33OSzZozCqFvGU86qkErBeq9YrCGfZiqzFymMl1Al1XLaxIQEBTa1jtfg/T8W@woyUcJG7ul9tjGPvxqVLo41S@ "Ruby – Try It Online") [Answer] # [Python 2](https://docs.python.org/2/), ~~56~~ 55 bytes ``` lambda n:int(''.join('12'[c>'0']for c in bin(n)[2:]),3) ``` [Try it online!](https://tio.run/##TYxNDoIwEEb3nmISF20TYzpTW5FEL4IsANOI0SkhbDx9hRqLy/e@n@E93QNT9OdrfDav9tYAlz1PUoj9I/QsBZKouovQovZhhA56hnb2rCoqa7UzKg7jPAAvUcEWaPNDWvCY0abUZD4t7IrMqFNfr/skCHGtkEkvaLX7fzIFfT0eyBI6jB8 "Python 2 – Try It Online") [Answer] # [Attache](https://github.com/ConorOBrien-Foxx/attache), 19 bytes ``` FromBase&3@1&`+@Bin ``` [Try it online!](https://tio.run/##SywpSUzOSP2fZmX7360oP9cpsThVzdjBUC1B28EpM@@/X2pqSnG0SkFBcnosV0BRZl5JSGpxiTNQVXF0mo5CtKGOkY6pjqWOoYGOkYGOoZExkGNsYWQaG/sfAA "Attache – Try It Online") This is a composition of three functions: `FromBase&3` * `1&`+` * `Bin` This first converts to binary (`Bin`), increments it (`1&`+`), then converts to ternary (`FromBase&3`). ## Alternatives Non-pointfree, 21 bytes: `{FromBase[Bin!_+1,3]}` Without builtins, 57 bytes: `Sum@{_3^(#_-Iota!_-1)}@{If[_>0,$[_/2\|Floor]'(1+_%2),[]]}` [Answer] # [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 36 bytes ``` .+ $ +`^(1+)\1 $1;1 ^ 1 +`1; ;111 1 ``` [Try it online!](https://tio.run/##K0otycxL/P9fT5tLRYtLOyFOw1BbM8aQS8XQ2pArjssQKGRozWVtaGjIZfj/vyUA "Retina 0.8.2 – Try It Online") Explanation: ``` .+ $* ``` Convert from decimal to unary. ``` +`^(1+)\1 $1;1 ``` Repeatedly divmod by 2, and add 1 to the result of the modulo. ``` ^ 1 ``` Add 1 to the first digit too. ``` +`1; ;111 ``` Convert from unary-encoded base 3 to unary. ``` 1 ``` Convert to decimal. [Answer] # [Japt](https://github.com/ETHproductions/japt), 6 bytes ``` ¤cÄ n3 ¤ // Convert the input to a base-2 string, c // then map over it as charcodes. Ä // For each item, add one to its charcode // and when that's done, n3 // parse the string as a base 3 number. ``` Takes input as a number, outputs a number. [Try it online!](https://tio.run/##y0osKPn//9CS5MMtCnnG//9bAgA "Japt – Try It Online") [Answer] # [MATL](https://github.com/lmendo/MATL), ~~12~~ ~~7~~ 6 bytes ``` BQ3_ZA ``` [Try it online!](https://tio.run/##y00syfn/3ynQOD7K8f9/SwA "MATL – Try It Online") Saved 5 bytes thanks to Giuseppe and another one thanks to Luis Mendo. Old 7 byte answer: ``` YBQc3ZA ``` [Try it online!](https://tio.run/##y00syfn/P9IpMNk4yvH/f0sA "MATL – Try It Online") ### Explanation: ``` YB % Convert to binary string Q % Increment each element c % Convert ASCII values to characters 3 % Push 3 ZA % Convert from base 3 to decimal. ``` --- Old one for 12 bytes: ``` BQtz:q3w^!Y* ``` [Try it online!](https://tio.run/##y00syfn/3ymwpMqq0Lg8TjFS6/9/SwA "MATL – Try It Online") Oh my, that was messy... So is this: `BQ3GBn:q^!Y\. ### Explanation: ``` % Implicit input B % Convert to binary vector Q % Increment all numbers t % Duplicate z % Number of element in vector : % Range from 1 to that number q % Decrement to get the range from 0 instead of 1 3 % Push 3 w % Swap order of stack ^ % Raise 3 to the power of 0, 1, ... ! % Transpose Y % Matrix multiplication % Implicit output ``` [Answer] # [C# (Visual C# Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 128 bytes ``` using System;using System.Linq;i=>{int z=0;return Convert.ToString(i,2).Reverse().Select(a=>(a-47)(int)Math.Pow(3,z++)).Sum();} ``` [Try it online!](https://tio.run/##TZBBS8QwEIXPya@YY@J2w27rolLbi@DJhWIFD@IhxHQ3sE0wSVfc0t8ep1LQEMLM8N6bj6iwVkGlIRh7gPY7RN2X9H8nnoz9LCkNUUajQJ1kCNB4d/Cy70dKlvnZmQ/YS2NZiB7db@8g/SHwkVJYzuNg1b2xMQN8auiqZKp6xBou1ab0Og7ewoOzZ@2jeHHtbw4zWc7Fs8Zh0IyLVp@0ikxWNZPr6xt@xTCA72U8isZ9sSK7rFYcZUPPeDmlkhLSOa@lOi5gYIceARY6AEJQQmYKC9VMJho5r0IZn90EiYI7afHqTdT4GZp1zPI/QM5LmDMmineiKW1TnnbpLm03Kd@kbV5gU9zmux8 "C# (Visual C# Compiler) – Try It Online") I am counting `System` because i use `Convert` and `Math`. [Answer] # [Python 2](https://docs.python.org/2/), ~~56~~ 54 bytes ``` lambda i:int(''.join(`int(x)+1`for x in bin(i)[2:]),3) ``` [Try it online!](https://tio.run/##FcxBCoQwDEDRq2Rng2GwKcJMwZOoYEWKGbQVcaGnr@3yv8U/nmuNgZPvhrS5fV4ciJVwqar6/KMENZW4sdaTjyfcIAHmzII92xHJYCruiveamFr6kW6IG9Jscpgvt6M9zrwBrxymFw "Python 2 – Try It Online") [Answer] # C, ~~32~~ 27 bytes ``` n(x){x=x?x%2+1+3n(x/2):0;} ``` Based on [user202729](https://codegolf.stackexchange.com/users/69850/user202729)'s Java [answer](https://codegolf.stackexchange.com/a/161625/79343). Try it online [here](https://tio.run/##S9ZNT07@/z9Po0KzusK2wr5C1UjbUNtYCyigb6RpZWBd@18hNzEzT0OzmksBCNLyizQy80oUMm0NrRUybQyNjYCUtrYmWFJBoaAIKJmmoaSaoqOkk6eRqalpDZYpKC0p1lBSgvHgqmLyQMoMjYxNNXHIWRpbGEEla7n@AwA). Thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) for golfing 5 bytes. Ungolfed version: ``` n(x) { // recursive function; both argument and return type are implicitly int x = // implicit return x ? x % 2 + 1 + 3n(x/2) // if x != 0 return x % 2 + 1 + 3n(x/2) (recursive call) : 0; // else return 0 } ``` [Answer] # [Husk](https://github.com/barbuz/Husk), 5 bytes ``` B3m→ḋ ``` [Try it online!](https://tio.run/##yygtzv7/38k491HbpIc7uv///29pbGFkCgA "Husk – Try It Online") ### Explanation ``` B3m→ḋ ḋ Convert to base 2 m→ Map increment B3 Convert from base 3 ``` [Answer] # [Octave](https://www.gnu.org/software/octave/) with the communication toolbox, ~~33~~ 32 bytes ``` @(x)(de2bi(x)+1)3.^(0:log2(x))' ``` [Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999Bo0JTIyXVKCkTyNA21NQy1ovTMLDKyU83Agpoqv9P0zDU5ErTMAIRpiDCEkQYGmj@BwA "Octave – Try It Online") Converts the input to a binary vector using `de2bi`, and incrementing all numbers. Does matrix multiplication with a vertical vector of 3* raised to the appropriate powers: `1, 3, 9, ...`, thus getting the sum without an explicit call to `sum`. [Answer] ## PHP, 84 64 Bytes [Try it online!!](https://tio.run/##FcpBCoAgEEDRq7QQcshF0SosOoo0NlIQo5i1ic5utvnw4Ict5HEOpe5im3bPlZOC4RE4rWRx51@a7OYrXE4y1vNNMUmBzZmiiRRoSbLualV4UNkRQPWqa0G/2ckBdP4A) ORIGINAL Code ``` function f($n){$b=decbin($n);echo base_convert($b+str_repeat('1',strlen($b)),3,10);} ``` [Try it online!!](https://tio.run/##K8go@G9jXwAk00rzkksy8/MU0jRU8jSrU5Mz8hWSEotT45Pz88pSi0o0ikuKSoo0UlKTkzLzQEp0DA10jAw1dYyBDE3r2v9pGpaa1v8B) Thanks to Cristoph, less bytes if ran with php -R ``` function f($n){echo base_convert(strtr(decbin($n),10,21),3,10);} ``` Explanation ``` function f($n){ $b=decbin($n); #Convert the iteger to base 2 echo base_convert( #base conversion PHP function $b+str_repeat('1',strlen($b)), #It adds to our base 2 number 3, #a number of the same digits length 10); #with purely '1's } ``` [Answer] # [CJam](https://sourceforge.net/p/cjam), 8 bytes ``` ri2b:)3b ``` [Try it online!](https://tio.run/##S85KzP3/vyjTKMlK0zjp/39LYwsjUwA "CJam – Try It Online") ### Explanation ``` ri e# Read input as an integer 2b e# Convert to base 2. Gives a list containing 0 and 1 :) e# Add 1 to each number in that list 3b e# Convert list from base 3 to decimal. Implicitly display ``` [Answer] # [Ruby](https://www.ruby-lang.org/), 28 bytes ``` f=->x{x>0?x%2+3f[x>>1]+1:0} ``` black magic, no idea how it works [Try it online!](https://tio.run/##KypNqvz/P81W166iusLOwL5C1UjbWCstusLOzjBW29DKoPZ/QWlJsUJadHpqSbFeSX58Zux/IwMA "Ruby – Try It Online") [Answer] # [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), 117 bytes ``` [S S S N _Push_0][S N S _Duplicate_0][S N S _Duplicate_0][T N T T _Read_STDIN_as_number][T T T _Retrieve][N S S S N _Create_Label_OUTER_LOOP][S N S _Duplicate][S S S T S N _Push_2][T S T T _Modulo][S S S T N _Push_1][T S S S _Add][S N T _Swap][S S S T S N _Push_2][T S T S _Integer_division][S N S _Duplicate][N T S N _If_0_jump_to_Label_INNER_LOOP][N S N S N _Jump_to_Label_OUTER_LOOP][N S S N _Create_Label_INNER_LOOP][S S S T T N _Push_3][T S S N _Multiply][T S S S _Add][S N T _Swap][S N S _Duplicate][N T S T N _If_0_jump_to_Label_PRINT_AND_EXIT][S N T _Swap][N S N N _Jump_to_Label_INNER_LOOP][N S S T N _Create_Label_PRINT_AND_EXIT][S N T _Swap][T N S T _Output_integer_to_STDOUT] ``` Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only. `[..._some_action]` added as explanation only. [Try it online](https://tio.run/##PYtBCoBADAPPySvyBkXQ54gs6E1Q8Pm16aJtGUI7ffbjbte5bi1CErNzQLj4bSSIEOBEU8W@LSmjVdZ/Xkr71RJgWqF6TiBiGedhegE) (with raw spaces, tabs and new-lines only). ### Explanation in pseudo-code: I first converted the recursive function `int f(int n){return n<1?0:n%2+1+3f(n/2);}` to its iterative form (in pseudo-code): ``` Integer n = STDIN as integer Add starting_value 0 to the stack function OUTER_LOOP: while(true){ Add n%2+1 to the stack n = n/2 if(n == 0): Jump to INNER_LOOP Else: Jump to next iteration OUTER_LOOP function INNER_LOOP: while(true){ n = 3n n = n + Value at the top of the stack (the ones we calculated with n%2+1) Swap top two items Check if the top is now 0 (starting value): Jump to PRINT_AND_EXIT Else: Swap top two items back Jump to next iteration INNER_LOOP function PRINT_AND_EXIT: Swap top two items back Print top to STDOUT as integer Exit program with error: Exit not defined ``` And I then implemented this iterative approach in the stack-based language Whitespace, using it's default stack. ### Example runs: Input: `1`* ``` Command Explanation Stack Heap STDIN STDOUT STDERR SSSN Push 0 [0] SNS Duplicate top (0) [0,0] SNS Duplicate top (0) [0,0,0] TNTT Read STDIN as integer [0,0] {0:1} 1 TTT Retrieve [0,1] {0:1} NSSSN Create Label OUTER_LOOP [0,1] {0:1} SNS Duplicate top (1) [0,1,1] {0:1} SSSTSN Push 2 [0,1,1,2] {0:1} TSTT Modulo top two (1%2) [0,1,1] {0:1} SSSTN Push 1 [0,1,1,1] {0:1} TSSS Add top two (1+1) [0,1,2] {0:1} SNT Swap top two [0,2,1] {0:1} SSSTSN Push 2 [0,2,1,2] {0:1} TSTS Int-divide top two (1/2) [0,2,0] {0:1} SNS Duplicate top (0) [0,2,0,0] {0:1} NTSN If 0: Go to Label INNER_LOOP [0,2,0] {0:1} NSSN Create Label INNER_LOOP [0,2,0] {0:1} SSSTTN Push 3 [0,2,0,3] {0:1} TSSN Multiply top two (03) [0,2,0] {0:1} TSSS Add top two (2+0) [0,2] {0:1} SNT Swap top two [2,0] {0:1} SNS Duplicate top (0) [2,0,0] {0:1} NTSTN If 0: Jump to Label PRINT [2,0] {0:1} NSSTN Create Label PRINT [2,0] {0:1} SNT Swap top two [0,2] {0:1} TNST Print top to STDOUT [0] {0:1} 2 error ``` [Try it online](https://tio.run/##PYtBCoBADAPPySvyBZ8ksqA3QcHn16SLtmUI7fTZj3tc57qNKkl0e0Ck@G0kiBCQxFDNuW3JMSr735fWfrUFhFGomQ1ULS8) (with raw spaces, tabs and new-lines only). Stops with error: Exit not defined. Input: `4`* ``` Command Explanation Stack Heap STDIN STDOUT STDERR SSSN Push 0 [0] SNS Duplicate top (0) [0,0] SNS Duplicate top (0) [0,0,0] TNTT Read STDIN as integer [0,0] {0:4} 4 TTT Retrieve [0,4] {0:4} NSSSN Create Label OUTER_LOOP [0,4] {0:4} SNS Duplicate top (4) [0,4,4] {0:4} SSSTSN Push 2 [0,4,4,2] {0:4} TSTT Modulo top two (4%2) [0,4,0] {0:4} SSSTN Push 1 [0,4,0,1] {0:4} TSSS Add top two (0+1) [0,4,1] {0:4} SNT Swap top two [0,1,4] {0:4} SSSTSN Push 2 [0,1,4,2] {0:4} TSTS Int-divide top two (4/2) [0,1,2] {0:4} SNS Duplicate top (2) [0,1,2,2] {0:4} NTSN If 0: Go to Label INNER_LOOP [0,1,2] {0:4} NSNSN Jump to Label OUTER_LOOP [0,1,2] {0:4} SNS Duplicate top (2) [0,1,2,2] {0:4} SSSTSN Push 2 [0,1,2,2,2] {0:4} TSTT Modulo top two (2%2) [0,1,2,0] {0:4} SSSTN Push 1 [0,1,2,0,1] {0:4} TSSS Add top two (0+1) [0,1,2,1] {0:4} SNT Swap top two [0,1,1,2] {0:4} SSSTSN Push 2 [0,1,1,2,2] {0:4} TSTS Int-divide top two (2/2) [0,1,1,1] {0:4} SNS Duplicate top (1) [0,1,1,1,1] {0:4} NTSN If 0: Go to Label INNER_LOOP [0,1,1,1] {0:4} NSNSN Jump to Label OUTER_LOOP [0,1,1,1] {0:4} SNS Duplicate top (1) [0,1,1,1,1] {0:4} SSSTSN Push 2 [0,1,1,1,1,2] {0:4} TSTT Modulo top two (1%2) [0,1,1,1,1] {0:4} SSSTN Push 1 [0,1,1,1,1,1] {0:4} TSSS Add top two (1+1) [0,1,1,1,2] {0:4} SNT Swap top two [0,1,1,2,1] {0:4} SSSTSN Push 2 [0,1,1,2,1,2] {0:4} TSTS Int-divide top two (1/2) [0,1,1,2,0] {0:4} SNS Duplicate top (0) [0,1,1,2,0,0] {0:4} NTSN If 0: Go to Label INNER_LOOP [0,1,1,2,0] {0:4} NSSN Create Label INNER_LOOP [0,1,1,2,0] {0:4} SSSTTN Push 3 [0,1,1,2,0,3] {0:4} TSSN Multiply top two (03) [0,1,1,2,0] {0:4} TSSS Add top two (2+0) [0,1,1,2] {0:4} SNT Swap top two [0,1,2,1] {0:4} SNS Duplicate top (1) [0,1,2,1,1] {0:4} NTSTN If 0: Jump to Label PRINT [0,1,2,1] {0:4} SNT Swap top two [0,1,1,2] {0:4} NSNN Jump to Label INNER_LOOP [0,1,1,2] {0:4} SSSTTN Push 3 [0,1,1,2,3] {0:4} TSSN Multiply top two (23) [0,1,1,6] {0:4} TSSS Add top two (1+6) [0,1,7] {0:4} SNT Swap top two [0,7,1] {0:4} SNS Duplicate top (1) [0,7,1,1] {0:4} NTSTN If 0: Jump to Label PRINT [0,7,1] {0:4} SNT Swap top two [0,1,7] {0:4} NSNN Jump to Label INNER_LOOP [0,1,7] {0:4} SSSTTN Push 3 [0,1,7,3] {0:4} TSSN Multiply top two (73) [0,1,21] {0:4} TSSS Add top two (1+21) [0,22] {0:4} SNT Swap top two [22,0] {0:4} SNS Duplicate top (0) [22,0,0] {0:4} NTSTN If 0: Jump to Label PRINT [22,0] {0:4} NSSTN Create Label PRINT [22,0] {0:4} SNT Swap top two [0,22] {0:4} TNST Print top to STDOUT [0] {0:4} 22 error ``` [Try it online](https://tio.run/##PYtBCoBADAPPySvyCD8ksqA3QcHn16SLtmUI7fTZj3tc57qNKkl0e0Ck@G0kiBCQxFDNuW3JMSr735fWfrUFhFGomQ1ULS8) (with raw spaces, tabs and new-lines only). Stops with error: Exit not defined. [Answer] # [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 74 bytes ``` ({<>(())<>({<({}[()])><>([{}]())<>})}(<>)){{}((({})()){}{}[{}])([][()])}{} ``` [Try it online!](https://tio.run/##HYsxCoBAEAO/kxQWKnbHfeS44iwEUSxsw759DTaBGSb7O85nOu5xZUKlAqRXBYoGdlZTU/TfBwOlklIALmircOmAaP1/mDPnZd0@ "Brain-Flak – Try It Online") ## "Readable" version ``` ({<>(())<> ({ <({}[()])> <> ([{}]()) <> }) } # At this point we have a inverted binary string on the stack (<>) ) { {} ( (({})()){}{}[{}] ) ([][()]) }{} ``` [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 4 bytes ``` b›3β ``` [Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=b%E2%80%BA3%CE%B2&inputs=9&header=&footer=) ``` b # Binary › # Increment 3β # From base 3 ``` [Answer] # [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 14 bytes ``` L,BBu1€+B]3$Bb ``` [Try it online!](https://tio.run/##S0xJKSj4/99Hx8mp1PBR0xptp1hjFaek////W/7LLyjJzM8r/q@rm5lbkJOZnFkCAA "Add++ – Try It Online") [Answer] # [Japt](https://github.com/ETHproductions/japt), 7 bytes ``` ¤£°XÃn3 ``` [Try it here](https://ethproductions.github.io/japt/?v=1.4.5&code=pKOwWMNuMw==&input=OA==) [Answer] # [Haskell](https://www.haskell.org/), 32 bytes ``` f 0=0 f a=1+mod a 2+3f(div a 2) ``` [Try it online!](https://tio.run/##FcdNDkAwEAbQvVN8Sz8TaaeRsOgRnEBEJqHRUARx/WL33izXMq1rjA7KqsRBrC7CPkLAhcldOvrndxaD@A0WQY52QHqcfrtRwmXoNDFV1JBWxIo0my@m5qqPLw "Haskell – Try It Online") ]
[Question] [ ## Introduction There are lots of utilities out there capable of creating a high CPU load to stress-test your processor(s). On Microsoft Windows, you can even use the on-board `calculator.exe`, enter a large number like `999999999`, and press `n!` several times to make your CPU(s) work overtime. But what’s in a solution if you didn’t create it yourself? ## The mission Your mission – if you choose to accept it – is to create the smallest CPU stress-test tool on the planet. ### Must… 1. must produce 100% CPU load until aborted 2. must take a numeric input, representing the number seconds the stress-test should run 3. must allow user interaction (keypress, closing terminal window, or something like that) which should enable a user to abort the stress-test and/or quit the program 4. must target Microsoft Windows, Mac OSx, and/or Linux. (Even a hamster could stress a Comodore64… therefore, you *must* target a current operating system.) ### Must not… 1. must not use 3rd-party programs or tools which replace expected functionality. (Proposing shortcuts in the likes of `system('cpuStressThing.exe')` disqualifies your proposal.) ### May… 1. may use any approach/algorithm/functionality to produce expected 100% CPU load 2. may use any programming or scripting language (as long as it allows practical verification of its functionality by running it) ## Winning Condition Present the smallest sourcecode possible. The winner is the one presenting the most minimal (in size) sourcecode that complies to the above “must” and “must not” conditions. Now, make that baby burn… --- *EDIT* Since the question came up in the comment area… you only need to target 1 CPU core. I'm definitely not expecting you to produce a multi-core solution. After all, this should be fun – not work. [Answer] # Bash and standard utilities, 36 31 22 29 28 26 bytes ``` yes :\|sh&sleep $1;kill $! ``` [Answer] # Bash/iputils (Linux), 14 bytes ``` ping6 -fw$1 :: ``` Flood-pings the IPv6 null address, until the -w deadline timer expires caveat - only consumes 55-60% CPU on my test VM Edit: - I retract my caveat. While `top` reports the `ping6` process only consumes 55-60% CPU, I see the total CPU idle percentage (2 core VM) approach zero. This presumably is because a good deal of the processing is going on in the kernel as it handles the packets. Note - must be run as root. As @Tobia comments, this seems like a reasonable requirement for something that will hog the CPU. And the OP approved it in the comments. [Answer] # Elf32 standalone binary - 86 bytes I bet this is the smallest correctly formed Elf format binary that can be made to perform this function. This will execute without any additional support on any linux based platform, or potentially even without an operating system. Binary download: <http://ge.tt/3m6h2cK1/v/0?c> Hex dump: ``` 0000000: 7f45 4c46 0101 0100 0000 0000 0000 0000 .ELF............ 0000010: 0200 0300 0100 0000 5480 0408 3400 0000 ........T...4... 0000020: 0000 0000 0000 0000 3400 2000 0100 0000 ........4. ..... 0000030: 0000 0000 0100 0000 0000 0000 0080 0408 ................ 0000040: 0080 0408 5600 0000 5600 0000 0500 0000 ....V...V....... 0000050: 0010 0000 75fe ....u. ``` This is done by building an asm file with a minimal Elf header of its own, and skipping the use of `ld` altogether. Assembly: ``` BITS 32 org 0x08048000 ehdr: ; Elf32_Ehdr db 0x7F, "ELF", 1, 1, 1, 0 ; e_ident times 8 db 0 dw 2 ; e_type dw 3 ; e_machine dd 1 ; e_version dd _start ; e_entry dd phdr - $$ ; e_phoff dd 0 ; e_shoff dd 0 ; e_flags dw ehdrsize ; e_ehsize dw phdrsize ; e_phentsize dw 1 ; e_phnum dw 0 ; e_shentsize dw 0 ; e_shnum dw 0 ; e_shstrndx ehdrsize equ $ - ehdr phdr: ; Elf32_Phdr dd 1 ; p_type dd 0 ; p_offset dd $$ ; p_vaddr dd $$ ; p_paddr dd filesize ; p_filesz dd filesize ; p_memsz dd 5 ; p_flags dd 0x1000 ; p_align phdrsize equ $ - phdr section .text global _start _start: jnz _start filesize equ $ - $$ ``` Built with `nasm -f bin tiny_cpu_stresser_elf32.asm -o tiny_cpu_stresser_elf32` [Answer] # bash builtins only 20 bytes ``` ulimit -t $1;exec $0 ``` [Answer] ## C, 52 ``` t;main(s){for(scanf("%d",&s),t=time();time()-t<s;);} ``` Press Ctrl+C to exit. ![enter image description here](https://i.stack.imgur.com/KcEtK.png) [Answer] ## Perl, 32 ``` for($i=<>,$t=time;time-$t<$i;){} ``` Now the embarrassing part: I foolishly put `$t=time` in front of `$i=<>` and was furiously trying to figure out why it exits a few seconds early. Again, Ctrl+C to exit. ![enter image description here](https://i.stack.imgur.com/AUY36.png) [Answer] ## Unix C, 47 ``` main(int a,charb){alarm(atoi(b[1]));for(;;);} ``` Pass the time on the command line. Interrupt key (Ctrl-C) aborts. [Answer] # Smalltalk (Smalltalk/X), 34 input: n; interrupt with CTRL-c or CMD-. ``` [[]loop]valueWithTimeout:n seconds ``` can golf better, if measured in days ;-) (just kidding): ``` [[]loop]valueWithTimeout:n days ``` ![enter image description here](https://i.stack.imgur.com/naDDc.png) or from a command line: ![enter image description here](https://i.stack.imgur.com/opX65.png) [Answer] # BrainFuck/[Extended BrainFuck](http://sylwester.no/ebf/): 3 ``` +[] ``` It will use 100% cpu on one core until aborted. All Brainfuck programs are valid EBF programs. # [Zozotez LISP](http://sylwester.no/zozotez/): 7 ~~15~~ ~~19~~ When using the little driver. ``` (:'r s) ; redfine read in the read-eval-print-loop ``` As a standalone expression without a driver: 15 ``` ((:'L(\()(L)))) ; setq a loop function and execute it ``` Usage: `echo '((\(L)(L))(\()(L)))' \| jitbf zozotez.bf` [Answer] This is not a serious attempt at it, but... # Bash, 12 bytes ``` :(){ :\|:&};: ``` As found on [Wikipedia](http://en.wikipedia.org/wiki/Fork_bomb). WARNING: harmful code, don't run it on your computer! --- Technically: - It produces 100% CPU load until system crashes; - Allows user interaction to stop it (if you manage to kill all the forks, you can actually stop it...); - You could give it a numeric input that represents the number of seconds it should run, but it won't use it. [Answer] ## Perl - 14 bytes ``` alarm<>;{redo} ``` Sets a `SIGALRM` to be sent in `input` seconds, which terminates the script. In the meantime, it spins in a busy-wait. Sample usage: ``` $ echo 4 \| perl stress.pl Terminating on signal SIGALRM(14) ``` --- ## Perl - 12 (+1) bytes If command line options are counted as one byte each, this could be reduced to 13 bytes** using a `-n`: ``` alarm;{redo} ``` Sample usage: ``` $ echo 4 \| perl -n stress.pl Terminating on signal SIGALRM(14) ``` [Answer] # PHP ~~43~~ 40 bytes: I hope this is an acceptable answer: ~~set\_time\_limit($\_REQUEST['t']);while(!0);~~ ``` <?for(set_time_limit($_REQUEST['t']);;); ``` I could do like this: `<?for(set_time_limit($_POST['t']);;);` but it would lose flexibility and 3 bytes. --- And i could cheat and do like this: `<?for(set_time_limit($_REQUEST[t]);;);`. It shaves off 2 bytes, but it's not a "standard" solution. Lets keep the game fair. --- As @fireeyedboy and @primo suggested, you can also use this solution (34 bytes): ``` <?for(set_time_limit($argv[1]);;); ``` This allows it's use from the console, calling it like this: ``` php <filename> <time in seconds> ``` As i told, I'm not targeting the console solution, but they have to get the credit for this one. Another answer could be this "monster", which is just both answers combined: ``` <?for(set_time_limit($argv[1]\|$_REQUEST['t']);;); ``` --- It's impossible to get key presses in php, without being on console, which I'm not targeting! To stop it, you MUST abort the process (stopping the page from loading might stop the code)! As a plus, it works in Android too! If you install a php server (free on Google Play). To make it work, simply do like this: You create a .php webpage and append `?t=<time in seconds>` to the end of the url or submit a post (using a form or even ajax). [Answer] # Python, ~~58~~ ~~55~~ 51 ~~Wow... longer than the C one. There's got to be a better way.~~ Still a tad long, but at least it beats the C solution! ``` import time;t=time.time;u=t()+input() while t()<u:1 ``` [Answer] ## x86\_64 assembly on Linux - 146 (source), 42 (assembled code) The NASM minified source (146 bytes): ``` xor rdi,rdi mov rcx,[rsp+16] mov rcx,[rcx] l: sub cl,'0' jl k imul rdi,10 movsx rdx,cl add rdi,rdx ror rcx,8 jmp l k: mov rax,37 syscall s: jmp s ``` Accepts a parameter on the command line specifying the number of seconds to run in the range (0, 9999999]; can be interrupted with the usual Ctrl-C. You can assemble it with ``` nasm -f elf64 -o stress.o stress.asm && ld -o stress stress.o ``` In theory it would be necessary to add a `global _start` followed by a `_start:` label at the beginning, but `ld` manages to fix it by itself with little fuss. The corresponding machine code (42 bytes): ``` 00000000 48 31 ff 48 8b 4c 24 10 48 8b 09 80 e9 30 7c 11 \|H1.H.L$.H....0\|.\| 00000010 48 6b ff 0a 48 0f be d1 48 01 d7 48 c1 c9 08 eb \|Hk..H...H..H....\| 00000020 ea b8 25 00 00 00 0f 05 eb fe \|..%.......\| 0000002a ``` (generated with `nasm` adding the `BITS 64` directive) A somewhat more readable version: ``` global _start _start: xor rdi,rdi mov rcx,[rsp+16] mov rcx,[rcx] argparse: sub cl,'0' jl alarm imul rdi,10 movsx rdx,cl add rdi,rdx ror rcx,8 jmp argparse alarm: mov rax,37 syscall loop: jmp loop ``` [Answer] # Batch, 2 characters `%0` In essence, the program constantly starts itself over and over. Your results may vary, due to processor task allocation priority, but it works for me. [Answer] # Go, ~~215~~ ~~212~~ 193 bytes (full) ``` package main import(."runtime" f"flag" ."strconv" ."time") func main(){f.Parse() c:=NumCPU()2 t,_:=Atoi(f.Arg(0)) GOMAXPROCS(c) for;c>0;c--{go(func(){for{Now()}})()} <-After(Duration(t)1e9)} ``` Bonus, stresses all CPU's. The `Now()` in the loop is there to kick in the scheduler, `Now` was the shortest function name I could find in my namespace If I run `go fmt` the size increases to ~~286~~ ~~277~~ 254 bytes [Answer] # Java - ~~154 148~~ 186 Weird error ate my `Thread.sleep()` part ``` public class Z{public static void main(String[]a) throws Exception{new Thread(){public void run(){for(;;);}.start();Thread.sleep(Byte.valueOf(a[0])1000);System.exit(0);}} ``` and a more readable version: ``` public class Z { public static void main(String[] a) throws Exception { new Thread() { public void run() { for (;;) ; } }.start(); Thread.sleep(Byte.valueOf(a[0]) 1000); System.exit(0); } } ``` Spawns a `new Thread` with a nice endless loop (`for(;;);`) then on main thread a `thread.sleep()` and a `System.exit(0)` after timeout to exit; ctrl-c exits, too on cmdline wasnt able to shorthand that `exit()`. crashing wont work; [Answer] # C# - 178 characters ``` using A=System.DateTime;class P{static void Main(string[]a){var b=A.Now.AddSeconds(int.Parse(a[0]));System.Threading.Tasks.Parallel.For(0,1<<30,(i,l)=>{if(A.Now>b)l.Stop();});}} ``` And more readable: ``` using A = System.DateTime; { class P { static void Main(string[] a) { var b = A.Now.AddSeconds(int.Parse(a[0])); System.Threading.Tasks.Parallel.For(0, 1 << 30, (i, l) => { if (A.Now > b)l.Stop(); }); } } } ``` Thats 178 chars in C# and uses all cores. The only weakness that it is always ending because of the 1<<30 integer limit. [Answer] # Powershell, ~~18~~ ~~54~~ 50 bytes To produce 100% load for all CPU cores. ``` for($s=date;($s\|% AddS* "$args")-ge(date)){sajb{}} ``` * The script takes a time in seconds as argument. * `\| AddS` is [the shortcut](https://codegolf.stackexchange.com/a/111526/80745) for `.AddSeconds()` method. `sajb` is the alias for `Start-Job` cmdlet. [Answer] ## Linux sh and standard utilities, 14 Recent gnu coreutils includes a `timeout` utility which is helpful: ``` timeout $1 yes ``` [Answer] # Matlab - 19 `tic;while toc<5;end` Replace `5` with desired execution time. [Answer] # Bash: 19 chars ``` function f(){ f;};f ``` [Answer] # Assembly: 16 bytes ``` _start:jg _start ``` Edit: Having not noticed the requirement to take a numeric input, i'm going to claim it does take one on the commandline, but ignores it =) [Answer] # DOS Batch - 5 bytes ``` %0\|%0 ``` # DOS Batch - 8 bytes ``` %0\|%0&%0 ``` Second is a translation of the infamous sh forkbomb. Ctrl+C breaks the program (unless you've tweaked the settings a little). [Answer] C#, 118 ``` using a=System.DateTime;class b{static void Main(string[]c){var d=a.Now.AddSeconds(int.Parse(c[0]));while(d>a.Now){}}} ``` Uncompressed ``` using a = System.DateTime; class b { static void Main(string[] c) { var d = a.Now.AddSeconds(int.Parse(c[0])); while (d > a.Now) { } } } ``` This requires a number as an argument which is the number of seconds to run. It will use 100% of one core for that much time or until crtl+c. I'm pretty sure this is as small as C# will go with its verbosity. [Answer] # Java - 88 characters ``` class S{public static void main(String[]a){for(long i=0;i<Long.valueOf(a[0]);){i=i+1;}}} ``` This allows for 2⁶³-1 loops. ### More Readable Version ``` class S { public static void main(String[] a) { for (long i = 0; i < Long.valueOf(a[0]);) { i = i + 1; } } ``` # C# - 87 characters ``` class S{public static void Main(string[]a){for(long i=0;i<long.Parse(a[0]);){i=i+1;}}} ``` ### More Readable Version ``` class S { public static void Main(string[] a) { for(long i = 0;i < long.Parse(a[0]);i++) { i = i + 1; } } } ``` ![The program pegging the core](https://i.stack.imgur.com/BKb8e.png) (This is on a 4 core system) [Answer] # EcmaScript 6: ``` z=z=>{while(1)z()};_=i=>(i+=1,i-=1,i++,i--,--i,++i,i<<=2,i>>=2,i+=0\|Math.round(1+Math.random())&1\|0,z(x=>setInterval(x=>z(x=>new Worker('data:text/javascript,'+_.toSource()),5))));setInterval(x=>z(x=>_(...Array(i=9e3).map((x,z)=>z3/22/44e2>>2<<2))),5) ``` This will use 100% of the CPU on a single-core machine, and with Firefox, it has the added bonus that Firefox keeps using up more and more memory; the whole interface locks up and the only way to stop it is to kill Firefox in the task manager. [Answer] # perl, 23 bytes I can't figure out how to paste a literal control-T here, so I've typed $^T instead, but either works (the literal is 1 char shorter at 23 bytes): ``` $e=$^T+<>;1 until$e<time ``` $^T is just the time the interpreter started, so you can basically read that as time() since it is the first thing we calculate. [Answer] # Python, 30 I found this old puzzle interesting, I hope it's OK to post an answer to an old question. I just couldn't let the C answers beat Python. ;) `sum(range(int(input())226))` This needs tuned for different CPUs, but I don't think that violates the OP... `sum(range(227))` pegs one of my 2.8GHz i7 cores for about a second. :) ]
[Question] [ Show the random result of a dice toss if done with a cube shaped die, in ASCII. ``` $ dice ``` should result in one of ``` ----- \| \| \| o \| \| \| ----- ----- \|o \| \| \| \| o\| ----- ----- \|o \| \| o \| \| o\| ----- ----- \|o o\| \| \| \|o o\| ----- ----- \|o o\| \| o \| \|o o\| ----- ----- \|o o\| \|o o\| \|o o\| ----- ``` [Answer] ## Python, 112 110 chars ``` from random import* r=randrange(6) C='o ' s='-----\n\|'+C[r<1]+' '+C[r<3]+'\|\n\|'+C[r<5] print s+C[r&1]+s[::-1] ``` [Answer] ## Ruby 1.9, 80 ~~84~~ characters ``` z=" o";$><<(s=?-5+" \|#{z[2/~a=rand(6)]} #{z[a/3]}\| \|"+z[a/5])+z[~a%2]+s.reverse ``` [Answer] ## Windows PowerShell, 89 ~~93~~ ~~96~~ ~~97~~ ~~101~~ ~~119~~ characters ``` -join('----- \|{0} {1}\| \|{2}{3}'-f'o '[$(!($x=random 6);$x-lt3;$x-ne5;$x%2)])[0..14+13..0] ``` [Answer] ## Golfscript, 56 characters ``` "-"5n"\|":\|"o "1/:&6rand:§1<=" "&§3<=\|n\|&§5<=]&§2%=1$-1% ``` The solution can be [tested here](http://golfscript.apphb.com/?c=Ii0iNSpuInwiOnwibyAiMS86JjZyYW5kOsKnMTw9IiAiJsKnMzw9fG58JsKnNTw9XSbCpzIlPTEkLTEl&run=true). [Answer] ### Python, 109 unicode characters ``` #coding:u8 print u"鱸헓ȅ᪮ԅ᪅餠☏汁끝鐸즪聗K糉툜㣹뫡燳闣≆뤀⩚".encode("u16")[2:].decode("zlib").split("\n\n")[id(list())%7-1] ``` Note: This does not used random function, so it will be not so random like others does. [Answer] ## Perl, 74 chars Run with `perl -M5.010`. ``` $-=rand 6;$_="----- \|0 2\| \|4";s/\d/$->$&?o:$"/ge;say$_,$-&1?$":o,~~reverse ``` (Note that the newlines in the listing are part of the string, and not just inserted for legibility.) If you find yourself wondering what the heck the `$->$` operation does, the following reading notes may be helpful: * The variable `$-` automatically truncates its assigned value to an integer. * The variable `$"` is preset to a single space. * `o` is a bareword (representing `"o"`). [Answer] First time golfer ## Python, 161 chars ``` from random import* n=randint(1,7) o,x='o ' a='-'5 b=(x,o)[n>3] d=(x,o)[n>5] c=(x,o)[n>1] print a+'\n\|'+c+x+b+'\|\n\|'+d+(x,o)[n%2]+d+'\|\n\|'+b+x+c+'\|\n'+a ``` [Answer] # Common Lisp 170* ``` (let((r(random 6))(a "----- \|")(c "o")(d " ")(e "\| \|")(f(concatenate 'string a(if(< r 1)d c)d(if(< r 3)d c)e(if(> r 4)c ))))(concatenate 'string f(if(evenp r)c d)(reverse f))) ``` Note that the newlines are significant. Unlike these silly "modern" languages, Common Lisp favors readability over succinctness, so we have the cumbersome "concatenate 'string..." construct and no succinct way to reference a character in a string. [Answer] ## JavaScript (169 168 141 137) ``` r=Math.random()6\|0;s='-----\n\|'+(r>0?'o ':' ')+(r>2?'o':' ')+'\|\n\|'+(r-5?' ':'o');alert(s+(r%2?' ':'o')+s.split('').reverse().join('')) ``` Doesn't look quite right in `alert` because it's not fixed-width font, but rest assured it is correct, or test by emitting a `<pre>` tag and doing `writeln` :-) Proof: <http://jsfiddle.net/d4YTn/3/> (only works in JS 1.7-compliant browsers, such as FF2+) Credits: Hacked `Math` trick from @minitech and die print logic from @Keith. Edit: Remove `Math` trick from @minitech because it actually made it longer :-) Edit 2: Save 17 chars. Borrow trick from @Keith for taking advantage of dice symmetry. Use trick for simplifying converting random number to int. Edit 3: Remove `1+` to shift random number from 1-6 to 0-5 and save 2 chars. As a result, I can also change `r%2-1` to `r%2` and save another 2 chars. Edit 4: jsfiddle is working again. Updated :-) [Answer] # JavaScript, ~~215~~ ~~213~~ ~~212~~ ~~145~~ 135 ``` r=Math.random()6\|0;alert('-----\n\|'+[r>2?'o o':r?'o ':' ',r%2?r>3?'o o':' ':' o ',r>2?'o o':r?' o':' '].join('\|\n\|')+'\|\n-----'); ``` Beat mellamokb, but I changed my original solution completely. If you want this to look good, use Google Chrome or something, change `alert` to `console.log`, and voilà. Edit: borrowed mellamokb's \|0 trick to save some characters. [Answer] PHP 119 126 128 131 188 201 213 234 239* ``` <?$c=($r=rand()%6)%2?$r>4?'o ':' ':' o';$b=$r>0?$r<3?'o ':'o o':' ';echo$a="-----\n\|$b\|\n\|$c",substr(strrev($a),1); ``` [Answer] Python 133 ``` import random as R i=R.randint(1,6) a=' ';b='0 0' A='-----\n\|'+((a,'0 ')[i>1],b)[i>3]+'\|\n\|' print A+((a,' 0 ')[i%2],b)[i>5]+A[::-1] ``` [Answer] ## F# - 165 161 characters ``` (System.Random()).Next 6\|>fun x->[for y in[x>0;x%2=0;x>2;x=5]->if y then"o"else" "]\|>fun[a;b;c;d]->printf"-----\n\|%s %s\|\n\|%s%s%s\|\n\|%s %s\|\n-----"a c d b d c a ``` [Answer] Python 108 114 119 121 122 129 wtf! looks like 1st solution ?! but iam not ... cheater 108 ``` import random as R i=R.randint(1,6) X=' 0' A='-----\n\|%s %s\|\n\|'%(X[i>1],X[i>3])+X[i>5] print A+X[i%2]+A[::-1] ``` 119 ``` import random as R i=R.randint(1,6) X=' 0';a=X[i>5] A='-----\n\|%s %s\|\n\|%s\|'%(X[i>1],X[i>3],a+X[i%2]+a) print A+A[-6::-1] ``` [Answer] ### perl - 111 103 101 ``` $n=int rand 6; ($t="-----\n\|0 1\|\n\|232\|\n\|1 0\|\n-----\n")=~s/(\d)/5639742>>6$1>>$n&1?o:$"/eg; die$t; ``` [Answer] ## APL (69) ``` 5 5⍴(5⍴'-'),{⊃⍵↓' o\|'}¨2,(⌽M),2,2,(N∊¨6(1 3 5)6),2,2,2,⍨M←3 6 1>⍨N←?6 ``` [Answer] ## Haskell, 154* 162 167 172 chars ``` import System.Random main=randomRIO(1::Int,6)>>=putStrLn. \x->let{h="-----\n\|"++c(>1):' ':c(>3):"\|\n\|"++[c(>5)];c f\|f x='o'\|True=' '}in h++c odd:reverse h ``` It uses roughly the same idea as the Python one. Readable version: ``` import System.Random main = do x <- randomRIO (1 :: Int, 6) putStrLn (render x) render x = str ++ check odd ++ reverse str where str = concat [ "-----\n\|" , check (> 1) , " " , check (> 3) , "\|\n\|" , check (> 5) ] check f = if f x then "o" else " " ``` [Answer] ### Golfscript ~~80~~ 65 ``` 6rand):^;'-'5n+:_[^6&0^4&^6=].^1&+-1%+3/{'\|'\{'o'' 'if+}/'\|'n}/_ ``` The program can be tested [here](http://golfscript.apphb.com/?c=NnJhbmQpOl47Jy0nNSpuKzpfW142JjBeNCZeNj1dLl4xJistMSUrMy97J3wnXHsnbycnICdpZit9Lyd8J259L18=&run=true) [Answer] PHP 126 127 179* ``` <?$x=($r=rand(1,6))>3?"o o":($r<2?" ":"o ");$z=$r>5?"o o":($r%2==0?" ":" o ");$v="-----\n\|$x\|\n";echo"$v\|$z\|".strrev($v); ``` Another PHP solution. I came to the almost same solution by Oleg. [Answer] C - 215 ``` #include <time.h> #include <stdlib.h> main(){char a[]=A,b[]=B,c=3,d=(srand(time(0)),rand()%6+1),e=d-2;if(d==1)a[5]=C;else{while(--e>-1)a[b[D[d-3]-48+e]-48]=C;a[0]=a[10]=C;}p(E);while(--c>-1)p("\|%s\|\n",a+c4);p(E);} ``` Compiles with: ``` cl /DA="\" \0 \0 \"" /DB="\"5282582468\"" /DC='o' /DD="\"0136\"" /DE="\"+---+\n\"" /Dp=printf dice.c ``` [Answer] ## Python (153) This is by far not the smallest submission, i just thought it looked nice :) ``` import random as r print"""----- \|%c %c\| \|%c%c%c\| \|%c %c\| -----"""%tuple( r.choice([ " o ", "o o", "o o o", "oo oo", "oo o oo", "ooo ooo"])) ``` [Answer] # Q (120 chars) ``` dice:{(`t`e`l`c`r`w!5 cut"-----\| \|\|o \|\| o \|\| o\|\|o o\|")(,/)(`t;(`e`c`e;`l`e`r;`l`c`r;`w`e`w;`w`c`w;`w`w`w)()1?6;`t)} ``` Usage: ``` dice[] ``` [Answer] # C, ~~168~~ ~~164~~ 163 chars Sorry if I'm a bit late to the party, but since no answer has been accepted yet, and the only other C solution was somewhat longer, here goes... ``` #include<stdio.h> main(){srand(time(0));charo="O ",r=rand()%6,i=o[r<1],j=o[r<3],k=o[r<5];printf("-----\n\|%c %c\|\n\|%c%c%c\|\n\|%c %c\|\n-----\n",i,j,k,o[r&1],k,j,i);} ``` You can remove the include and save another 18 chars, but then it doesn't compile without warnings. Edit: using [user23241's command-line trick](https://codegolf.stackexchange.com/a/2662/4208), the shortest C code that produces the result (without compiler warnings) is only 12 chars: ``` #include I M ``` At least if you cheat and use the following command line to compile: ``` gcc -DI="<stdio.h>" -DM="main(){srand(time(0));charo=\"O \",r=rand()%6,i=o[r<1],j=o[r<3],k=o[r<5];printf(\"-----\n\|%c %c\|\n\|%c%c%c\|\n\|%c %c\|\n-----\n\",i,j,k,o[r&1],k,j,i);}" dice.c -o dice ``` [Answer] # c, 140 chars ``` r,i,s;main(){srand(time(i=0));r=rand()%6;for(s=-1;i-=s;)putchar("\n\| \|-o"[i>5?i==8&&r\|\|i==10&&2<r\|\|i==14&&4<r\|\|i==15&&(s=1)&~r?7:i%6:6]);} ``` [Answer] ## PHP:1284 This is my second CodeGolf, and I wasn't really aiming for shortness as much as code mutability and matching the gaming criteria. You can generate 4 sided dice as well as 6 sided. Maybe later I will shorten it and make it a little more dynamic. ``` function draw_dice($numdice=1,$sides=4) { /* Verify acceptable parameters. / if($sides<4){die("You must choose 4 sides or greater.");} if($numdice<1){die("You must have at least one dice.");} / End verification / $a=' '; $b=' '; $c=' '; $d=' '; $e=' '; $f=' '; $g=' '; $h=' '; $i=' '; $j=' '; switch($sides) { case $sides%2==0: if($sides==4) { $ran=rand(1,$sides); switch($ran) { case 1: $e="o"; break; case 2: $a="o"; $j="o"; break; case 3: $b="o"; $g="o"; $j="o"; break; case 4: $a="o"; $c="o"; $g="o"; $j="o"; break; } echo "<div style='text-align:center;display:inline-block;'>"; echo " - <br/>"; echo "\| \|<br/>"; echo "\|$a$b$c\|<br/>"; echo "\| $d$e$f \|<br/>"; echo "\| $g$h$i$j \|<br/>"; echo "---------<br/>"; echo "</div>"; } if($sides==6) { $ran=rand(1,$sides); switch($ran) { case 1: $e="o"; break; case 2: $a="o"; $i="o"; break; case 3: $a="o"; $i="o"; $e="o"; break; case 4: $a="o"; $c="o"; $g="o"; $i="o"; break; case 5: $a="o"; $c="o"; $g="o"; $i="o"; $e="o"; break; case 6: $a="o"; $c="o"; $d="o"; $f="o"; $g="o"; $i="o"; break; } echo "-----<br/>"; echo "\|$a$b$c\|<br/>"; echo "\|$d$e$f\|<br/>"; echo "\|$g$h$i\|<br/>"; echo "-----<br/>"; } if($sides!==4&&$sides!==6) { die("Only 4 and 6 sided are supported at this time."); } break; case $sides%2==1: die("Must have even number of sides."); break; } } draw_dice(1,4); ``` ## Output 4 sided: ``` - \| \| \|o o\| \| \| \| o o \| --------- ``` ## Output 6 sided: ``` ----- \|o \| \| o \| \| o\| ----- ``` [Answer] ## JavaScript 220 bytes ``` r=(1+Math.random()6\|0).toString(2).split("").reverse();b=r[1];c=r[2];s=[[b\|c,0,c],[b&c,1&r[0],b&c],[c,0,b\|c]];"-----\n\|"+s.map(function(v){return v.map(function(w){return w?"o":" "}).join("")}).join("\|\n\|")+"\|\n-----"; ``` [Answer] ### Ruby , 134 132 119 118 117 112 111 chars, My second golf in life. I've used magic numbers. Any advises please? ``` r=?-5+" \|"+((a=:ghklm[rand 6])?a.to_i(36).to_s(2).tr("10","o "):" o").insert(3,"\| \|") $><<r+r[0,14].reverse ``` Outputs: ``` ice@distantstar ~/virt % ruby ./golf.rb ----- \|o o\| \| \| \|o o\| ----- ice@distantstar ~/virt % ruby ./golf.rb ----- \|o o\| \|o o\| \|o o\| ----- ice@distantstar ~/virt % ruby ./golf.rb ----- \| \| \| o \| \| \| ----- ice@distantstar ~/virt % ``` [Answer] ## VimScript – 169 chararacters Note that this is not pure Vim since Vim has no builtin random number generator. There are extensions that can be downloaded for it of course, but since I am a diehard Linux man, I thought, why not just rely on the shell environment instead. ### Code ``` norm5a-^[YPo\| \|^[YPP let x=system('echo $RANDOM')%6+1 if x<2 norm jllro el norm lrolljj.k if x>3 norm k.hjj en if x>2 norm h.k en if x>5 norm .l en if x>4 norm l. en en ``` ### Explanation The first line generators the "box" that represents the die. * The second line fetches a random number from the environment and using modular arithmetic forces it to be a valid number for a dice. * The remaining lines move around the die face filling in the `o` 's. Note that this is meant to be optimized for the least number of characters, not the least number of movements (i.e. there would be faster ways in turns of keystrokes if I was doing it manually—doing the `if`s all in my head). * As always, `^` is not a literal `^` but an indication of an escape sequence. ### Testing Change `RANDOM` to `DICEVALUE`, save the VimScript code into `dice.vim`, then run this shell script on it, giving as arguments whatever numbers you want to test: ``` #!/bin/sh for DICEVALUE in $@; do export DICEVALUE vim -S dice.vim done ``` [Answer] # Mathematica 166 161 146 143 chars ``` a="O ";b=" O ";c=" O";d=" ";e="O O";RandomInteger@{1, 6}/.Thread@Rule[Range@6,{{d,b,d},{a,d,c},{a,b,c},{e,d,e},{e,b,e}, {e,e,e}}]//MatrixForm ``` Sample Output: ![five](https://i.stack.imgur.com/6K7mq.png) --- If the matrix braces offend, you may replace `MatrixForm` with `TableForm` in the code. [Answer] # PHP 5.4, 107 bytes ``` <?$r=rand(1,6);$d=[' ','o'];$o='+---+ \|'.$d[$r>1].' '.$d[$r>3].'\| \|'.$d[$r>5];echo$o.$d[$r%2].strrev($o); ``` 102 bytes\* ``` <?$r=rand(1,6);$d=' o';$o='+---+ \|'.$d[$r>1].' '.$d[$r>3].'\| \|'.$d[$r>5];echo$o.$d[$r%2].strrev($o); ``` \\Unfortunately, the 102 byte version issues notices due to the casting of `bool` to `int` when indexing the string `$d`. Other than that, it works fine.\* ]
[Question] [ Create a bot to choose the smallest unique number. (Based on a psychology experiment I heard about many years ago but haven't been able to track down again.) ### Rules * Each game will consist of 10 randomly selected bots playing 1000 rounds. * Each round, all bots select an integer from 1 to 10 (inclusive). Any bots that choose the same value will be be excluded, and the remaining bot with the smallest value will receive a point. * In the event that no bot picks a unique value, no points will be awarded. * At the end of 1000 rounds, the bot with the most points (or all bots tied with the most points) wins the game. * The tournament will last 200 \* (number of players) games. * The bot with the highest win percentage wins the tournament. ### Specifications Bots must be Python 3 classes and must implement two methods: `select` and `update`. Bots will be constructed with an index. `select` is passed no arguments and returns the bot's choice for the current round. `update` is passed a list of the choices made by each bot in the previous round. ### Example ``` class Lowball(object): def __init__(self, index): # Initial setup happens here. self.index = index def select(self): # Decision-making happens here. return 1 def update(self, choices): # Learning about opponents happens here. # Note that choices[self.index] will be this bot's choice. pass ``` ### Controller ``` import numpy as np from bots import allBotConstructors allIndices = range(len(allBotConstructors)) games = {i: 0 for i in allIndices} wins = {i: 0 for i in allIndices} for _ in range(200 * len(allBotConstructors)): # Choose players. playerIndices = np.random.choice(allIndices, 10, replace=False) players = [allBotConstructors[j](i) for i, j in enumerate(playerIndices)] scores = [0] * 10 for _ in range(1000): # Let everyone choose a value. choices = [bot.select() for bot in players] for bot in players: bot.update(choices[:]) # Find who picked the best. unique = [x for x in choices if choices.count(x) == 1] if unique: scores[choices.index(min(unique))] += 1 # Update stats. for i in playerIndices: games[i] += 1 bestScore = max(scores) for i, s in enumerate(scores): if s == bestScore: wins[playerIndices[i]] += 1 winRates = {i: wins[i] / games[i] for i in allIndices} for i in sorted(winRates, key=lambda i: winRates[i], reverse=True): print('{:>40}: {:.4f} ({}/{})'.format(allBotConstructors[i], winRates[i], wins[i], games[i])) ``` ### Additional information * No bot will play in a game against itself. * In the unlikely event that a bot is included in less than 100 games, the tournament will be rerun. * Bots may store state between rounds, but not between games. * Accessing the controller or other bots is not allowed. * The number of games and number of rounds per game are subject to increase if the results are too variable. * Any bots that raise errors or give invalid responses (non-ints, values outside [1, 10], etc.) will be disqualified, and the tournament will be rerun without them. * There is no time limit for rounds, but I may implement one if bots take too long to think. * There is no limit on the number of submissions per user. * ~~The deadline for submissions is 23:59:59 UTC on Friday, September 28.~~ The tournament is now closed for submissions. ### Results ``` BayesBot: 0.3998 (796/1991) WhoopDiScoopDiPoop: 0.3913 (752/1922) PoopDiScoopty: 0.3216 (649/2018) Water: 0.3213 (660/2054) Lowball: 0.2743 (564/2056) Saboteur: 0.2730 (553/2026) OneUpper: 0.2640 (532/2015) StupidGreedyOne: 0.2610 (516/1977) SecondSaboteur: 0.2492 (492/1974) T42T: 0.2407 (488/2027) T4T: 0.2368 (476/2010) OpportunityBot: 0.2322 (454/1955) TheGeneral: 0.1932 (374/1936) FindRepeats: 0.1433 (280/1954) MinWin: 0.1398 (283/2025) LazyStalker: 0.1130 (226/2000) FollowBot: 0.1112 (229/2060) Assassin: 0.1096 (219/1999) MostlyAverage: 0.0958 (194/2024) UnchosenBot: 0.0890 (174/1955) Raccoon: 0.0868 (175/2015) Equalizer: 0.0831 (166/1997) AvoidConstantBots: 0.0798 (158/1980) WeightedPreviousUnchosen: 0.0599 (122/2038) BitterBot: 0.0581 (116/1996) Profiteur: 0.0564 (114/2023) HistoryBot: 0.0425 (84/1978) ThreeFourSix: 0.0328 (65/1984) Stalker: 0.0306 (61/1994) Psychadelic: 0.0278 (54/1943) Unpopulist: 0.0186 (37/1994) PoissonsBot: 0.0177 (35/1978) RaccoonTriangle: 0.0168 (33/1964) LowHalfRNG: 0.0134 (27/2022) VictoryPM1: 0.0109 (22/2016) TimeWeighted: 0.0079 (16/2021) TotallyLost: 0.0077 (15/1945) OneTrackMind: 0.0065 (13/1985) LuckySeven: 0.0053 (11/2063) FinalCountdown: 0.0045 (9/2000) Triangle: 0.0039 (8/2052) LeastFrequent: 0.0019 (4/2067) Fountain: 0.0015 (3/1951) PlayerCycle: 0.0015 (3/1995) Cycler: 0.0010 (2/1986) SecureRNG: 0.0010 (2/2032) SneakyNiner: 0.0005 (1/2030) I_Like_Nines: 0.0000 (0/1973) ``` [Answer] # BayesBot Tries to make the optimal choice using a simple statistical model. ``` import random def dirichlet(counts): counts = [random.gammavariate(n, 1) for n in counts] k = 1. / sum(counts) return [n * k for n in counts] class BayesBot(object): def __init__(self, index): self.index = index self.counts = [[0.2 * (10 - i) for i in range(10)] for _ in range(10)] def select(self): player_distributions = [] for i, counts in enumerate(self.counts): if i == self.index: continue player_distributions.append(dirichlet(counts)) cumulative_unique = 0. scores = [0.] * 10 for i in range(10): p_unpicked = 1. for d in player_distributions: p_unpicked = (1. - d[i]) p_unique = p_unpicked sum(d[i] / (1. - d[i]) for d in player_distributions) scores[i] = p_unpicked * (1. - cumulative_unique) cumulative_unique += p_unique * (1. - cumulative_unique) return scores.index(max(scores)) + 1 def update(self, choices): for i, n in enumerate(choices): self.counts[i][n - 1] += 1 ``` [Answer] # Avoid Constant Bots Keep track of which bots have always returned the same value, and skip those values. Of the remaining values, select them randomly, but biased significantly towards lower values. ``` import numpy as np class AvoidConstantBots(object): all_values = range(1, 11) def __init__(self, index): self.index = index self.constant_choices = None def select(self): available = set(self.all_values) if self.constant_choices is not None: available -= set(self.constant_choices) if len(available) == 0: available = set(self.all_values) values = np.array(sorted(available)) weights = 1. / (np.arange(1, len(values) + 1)) 1.5 weights /= sum(weights) return np.random.choice(sorted(available), p=weights) def update(self, choices): if self.constant_choices is None: self.constant_choices = choices[:] self.constant_choices[self.index] = None else: for i, choice in enumerate(choices): if self.constant_choices[i] != choice: self.constant_choices[i] = None ``` [Answer] # WaitWhatBot Not the most competitive bot and definitely not [GTO](https://en.wikipedia.org/wiki/Nash_equilibrium "Game Theory Optimal"), but will stifle the score of any "always 1" or "nearly always 1" opponent in the same game as in such a scenario WaitWhatBot becomes such a bot too. Uses evolving probabilities with weighted weights both in time (more recent -> greater weight) and choice value (lower point -> greater weight). Uses somewhat obfuscated code for a bit of a giggle. ``` from random import choices as weightWeight class WaitWhatBot(object): def __init__(wait,what): weight,weightWhat=5,2 wait.what,wait.weight=what,(weight(weight/weight/weightWhat)+weightWhat/weightWhat)/weightWhat wait.whatWeight,wait.weightWeight=[wait.what==wait.weight]int(wait.weightweight),wait.weight wait.whatWhat=wait.whatWeight.pop()#wait, when we pop weight off whatWeight what weight will pop? wait.waitWait=tuple(zip(enumerate(wait.whatWeight,wait.weightWeight!=wait.whatWeight)))[weightWeight==wait.weight] def select(what):return int(what.weight*what.whatWhat if all(not waitWait for waitWait in what.whatWeight)else weightWeight(what.waitWait,what.whatWeight)[what.weight==what.what]) def update(waitWhat,whatWait): what,wait,weightWhat=set(wait for wait in whatWait[:waitWhat.what]+whatWait[waitWhat.what+1:]if wait in waitWhat.waitWait),-~waitWhat.whatWhat,waitWhat.weightWeight while wait not in what: waitWhat.whatWeight[wait+~waitWhat.whatWhat]+=weightWhat weightWhat/=waitWhat.weight wait-=~waitWhat.whatWhat if not wait!=(what!=weightWhat):waitWhat.whatWeight[waitWhat.whatWhat]+=weightWhat waitWhat.weightWeight=waitWhat.weight ``` [Answer] # Flow Like Water Avoids basic constant bot detection algorithms by doubling up on each number, slowly advancing toward lower values if they're unoccupied. ``` class Water(object): def __init__(self, index): self.index = index self.round = 0 self.play = 4 self.choices = [0]10 def select(self): if self.round > 0 and self.round%2 == 0: if not max([1, self.play - 1]) in self.choices: self.play -= 1 return self.play def update(self, choices): self.round += 1 self.choices = choices ``` [Answer] # Stalker At the start of the game, this bot randomly chooses a specific index as its target. It then stalks that target the entire game, copying the number that it chose in the previous round. ``` import random class Stalker(object): def __init__(self, index): # choose a random target to stalk that isn't ourself self.targetIndex = random.choice([x for x in range(10) if x != index]) # get a random number to start with since we haven't seen our target's value yet self.targetValue = random.randint(1, 10) def select(self): return self.targetValue def update(self, choices): # look at what our target chose last time and do that self.targetValue = choices[self.targetIndex] ``` [Answer] # Whoop-di-scoop-di-poop ``` class WhoopDiScoopDiPoop(object): def __init__(self, index): self.index = index self.guess = 1 self.tenure = 0 self.perseverance = 4 def select(self): return self.guess def update(self, choices): others = {c for i, c in enumerate(choices) if i != self.index} for i in range(1, self.guess): if i not in others: self.guess = i self.tenure = 0 self.perseverance += 1 return if self.guess not in others: self.tenure = 0 return self.tenure += 1 if self.tenure > self.perseverance: if self.guess == 10: return self.guess += 1 self.tenure = 0 ``` # Poop-di-scoopty ``` class PoopDiScoopty(object): def __init__(self, index): self.index = index self.guess = 1 self.tenure = 0 self.perseverance = 4 def select(self): return self.guess def update(self, choices): others = [c for i, c in enumerate(choices) if i != self.index] for i in range(1, self.guess): if i not in others: self.guess = i self.tenure = 0 self.perseverance += 1 return if self.guess not in others: self.tenure = 0 return self.tenure += others.count(self.guess) # this is the change if self.tenure > self.perseverance: if self.guess == 10: return self.guess += 1 self.tenure = 0 ``` I've never seen or touched Python, is this unpythonic? [Answer] # Opportunitybot This bot keeps track of the lowest number not chosen by any other bots each round (the lowest available number, or opportunity), and plays the number that has been that number most frequently. ``` class OpportunityBot(object): def __init__(self, index): self.index = index self.winOccasions = [0,0,0,0,0,0,0,0,0,0] def select(self): return self.winOccasions.index(max(self.winOccasions))+1 def update(self, choices): choices.pop(self.index) succeeded = [choices.count(i)==0 for i in range(1,11)] self.winOccasions[succeeded.index(True)] += 1 ``` [Answer] # Stupid Greedy One ``` class StupidGreedyOne(object): def __init__(self, index): pass def select(self): return 1 def update(self, choices): pass ``` This bot assumes that other bots don't want to tie. I realize this is the same as the provided example but I had the thought before I'd read that far. If this is incongruous with how KoTH challenges are run, let me know. [Answer] # The top 50% RNG bot ``` import random class LowHalfRNG(object): def __init__(self, index): pass def select(self): return random.randint(1, 5) def update(self, choices): pass ``` I was about to post a random bot, but hidefromkgb posted before me (by posting they're making themselves an easy target for the KGB, not a good way to hide). This is my first KOTH answer, just hoping to beat the rng bot. [Answer] # HistoryBot ``` import random class HistoryBot(object): def __init__(self, index): self.pastWins = [] def select(self): if not self.pastWins: return 1 return random.choice(self.pastWins) def update(self, choices): unique = [x for x in choices if choices.count(x) == 1] if unique: self.pastWins.append(min(unique)) ``` Implementation of user2390246's comment: > > What about this then? Start with 1. After the first round, keep track > of the winning values and pick randomly from them with probability > equal to the number of occurrences. E.g. if the winning values in the > first three rounds are [2, 3, 2] then in round four, pick [2] with p = > 2/3 and [3] with p = 1/3. > > > [Answer] ## OneUpper ``` class OneUpper(object): def __init__(self, index): self.index = index def select(self): return 2 def update(self, choices): pass ``` Everyone else's bots are either aiming for 1 or random, so why not just aim for 2? [Answer] # The Final Countdown ``` class FinalCountdown(object): def __init__(self, index): self.round = -1 def select(self): self.round += 1 return (10 - self.round // 100) def update(self, choices): pass ``` [Try it online!](https://tio.run/##bY/BCoMwEETvfsUeE2o10lvBU6G/IWmyqSmykSTS9uvtWkSkdI@zM4@Z8Z37QKd5NoNOCa6e9HAJE2UbniTC7YEmy3MBfBYddJ0nn7tOJBxcCZ4svtb3cotaRY5baOHYbDHWmfMN/XcfWmg2PWKeIoFoFBz3prqGRim5UafR6oxrFdMHbzDt8CMPmp3hJj@rGFG4EMFzf4ia7ihUyWS1hsfoKQtnqrW2lPMH "Python 3 – Try It Online") Returns 10 for the first 100 rounds, 9 for the next 100 and so on. [Answer] # PatterMatcher Looks for repeating sections in the submissions of the bots, tries to predict and avoid there numbers. ``` class PatternMatcher(object): def __init__(self, index): self.bots=[[]]9 self.index=index def select(self): minVisible=3 #increase these if this bot is to slow minOccurences=2 predictions=set() for bot in self.bots: #match patters of the form A+(B+C)minOccurences+B and use C[0] as a prediction for lenB in range(minVisible,len(bot)//(minVisible+1)+1): subBot=bot[:-lenB] patterns=[] for lenBC in range(lenB,len(subBot)//minOccurences+1): BC=subBot[-lenBC:] for i in range(1,minOccurences): if BC!=subBot[-lenBCi-lenBC:-lenBCi]: break else: patterns.append(BC) predictions\|={pattern[lenB%len(pattern)] for pattern in patterns} other=set(range(1,11))-predictions if other: return min(other) else: return 1 def update(self, choices): j = 0 for i,choice in enumerate(choices): if i == self.index: continue self.bots[j].append(choice) j += 1 ``` # Triangle The chance of picking n is `(10-n)/45` ``` import random class Triangle(object): def __init__(self, index):pass def select(self):return random.choice([x for x in range(1, 11) for _ in range(10 - x)]) def update(self, choices):pass ``` # TimeWeighted The probability a bot chooses a number is proportional to `(10-n)Δt`. The first round this is identical to triangle. ``` import random class TimeWeighted(object): def __init__(self, index): self.last=[0]10 self.round=1 def select(self): weights=[(self.round-self.last[i])(10-i) for i in range(10)] return 1+random.choice([x for x in range(10) for _ in range(weights[x])]) def update(self, choices): for c in choices: self.last[c-1]=self.round self.round+=1 ``` # LeastFrequent Submits the least frequently occurring number, if they are equal, take the lowest one. ``` class LeastFrequent(object): def __init__(self, index):self.frequenties=[0]10 def select(self):return 1+self.frequenties.index(min(self.frequenties)) def update(self, choices): for c in choices: self.frequenties[c-1]+=1 ``` # LongestTime Same as with frequenties but with the longest time between submissions. ``` class LongestTime(object): def __init__(self, index): self.frequencies=[0]10 self.round=1 def select(self):return 1+self.frequencies.index(min(self.frequencies)) def update(self, choices): for c in choices: self.frequencies[c-1]=self.round self.round+=1 ``` # Saboteur Submits the lowest number which was submitted last time. ``` class Saboteur(object): def __init__(self, index):self.last=[1] def select(self):return min(self.last) def update(self, choices):self.last=choices ``` # SecondSaboteur Submits the second lowest number which was submitted last time ``` class SecondSaboteur(object): def __init__(self, index):self.last=[1,2] def select(self):return min({i for i in self.last if i!=min(self.last)}) def update(self, choices):self.last=choices ``` # Profiteur Submits the lowest number not submitted last time ``` class Profiteur(object): def __init__(self, index):self.last=set() def select(self):return min(set(range(1, 11))-self.last, default=1) def update(self, choices):self.last=set(choices) ``` Sorry I got a bit carried away, getting idea for new bots while implementing the previous once. I wasn't sure which one would be the best and I'm curious about the performance of each of them. You can find them all here: <https://repl.it/@Fejfo/Lowest-Unique-Number> [Answer] # The Cycler This bot simply cycles through each of the numbers on its turns. Just for fun, it initializes the counter with its index. ``` class Cycler(object): def __init__(self, index): self.counter = index # Start the count at our index def select(self): return self.counter + 1 # Add 1 since we need a number between 1-10 def update(self, choices): self.counter = (self.counter + 1) % 10 ``` [Answer] # Totally Lost ``` class TotallyLost(object): def __init__(self, index): self.index = index self.round = 0 self.numbers = [4,8,1,5,1,6,2,3,4,2] def select(self): return self.numbers[self.round % len(self.numbers)] def update(self, choices): self.round = self.round + 1 ``` [Answer] ## OneTrackMind This bot randomly picks a number and sticks with it for 50 rounds, then picks another and repeats. ``` import random class OneTrackMind(object): def __init__(self, index): self.round = 0; self.target = random.randint(1,10) def select(self): return self.target def update(self, choices): self.round += 1; if self.round % 50 == 0: self.target = random.randint(1,10) ``` [Answer] # Lucky Seven ``` class LuckySeven(object): def __init__(self, index): pass def select(self): return 7 def update(self, choices): pass ``` I'm feeling lucky today! I'm throwing out everything on 7! [Answer] My idea is that the strategy is more dependent on the number of bots than on actual evaluation of strategies. With a significant number of bots, the options are: * "Greedy" robots aiming to the lower 1-3 numbers 10 bots being "clever" and aiming to get the lower 1-3 numbers, the best is to just let those bots interfere between them. * "Smart" robots who, once they realize 4 is always picked up, will go elsewhere. * "Random" and "constant" robots. Not much to do here. So, I bet on #4. ``` class LazyStalker(object): def __init__(self, index): pass def select(self): return 4 def update(self, choices): pass ``` [Answer] # The essential RNG bot ``` import secrets class SecureRNG(object): def __init__(self, index): pass def select(self): return secrets.randbelow(10) + 1 def update(self, choices): pass ``` [Answer] # Assassin Stays in the shadows, then aims for the current lowest guess. Run. ``` class Assassin(object): def __init__(self, index): self.index = index self.round = 0 self.choices = [0]10 def select(self): if self.round == 0: return 10 else: return min(self.choices) def update(self, choices): self.round += 1 self.choices = choices self.choices[self.index] = 10 ``` [Answer] # FollowBot Copy the winner from the last round, or at least the best minimally-tied selection if there was no winner. ``` import collections class FollowBot(object): def __init__(self, index): self.lastround = [] def select(self): counter = collections.Counter(self.lastround) counts = [(count,value) for (value,count) in counter.items()] counts.sort() if len(counts) >= 1: return counts[0][1] else: return 1 def update(self, choices): self.lastround = choices ``` [Answer] ## Psychadelic The only way to win a nuclear war is to make yourself insane. So I'm going to make every predictive bot in the tournament insane. ``` class Psychadelic(object): def __init__(self, index): self.index = index def select(self): return random.randint(1, self.index + 1) def update(self, choices): pass ``` [Answer] # UnchosenBot ``` class UnchosenBot(object): def __init__(self, index): self.index = index self.answer = 0 def select(self): if self.answer == 0: return 1 return self.answer def update(self, choices): self.answer = 0 del choices[self.index] for x in range(1, 11): if x not in choices: self.answer = x return ``` Takes the last round's choices, and chooses the lowest unchosen number (ignoring UnchosenBot's choice, of course). [Answer] # Fountain A simple bot, picks the lowest number first and if any other bot chooses it too, it will increment the counter - the floor gets filled and the water flows down. When it reaches 11, it restarts to 1 - the water gets pumped back to the top. ``` class Fountain: def __init__(self, index, target=10): # Set data self.index = index self.pick = 1 self.target = target+1 def select(self): # Select the number return self.pick def update(self, choices: list): # Remove self from the list choices.pop(self.index) # I hope `choices[:]` is passed, not `choices`. # While the selected number is occupied while self.pick in choices: # Pick next number self.pick += 1 # If target was reached if self.pick == self.target: # Reset to 1 self.pick = 1 ``` [Answer] # PoissonsBot Select numbers from a Poisson distribution which is biased to lower values. Adjust the mean parameter of the distribution up if we are in a tie and down if there are guesses below us. Step size gets progessively smaller as the game proceeds. ``` from numpy.random import poisson import math class PoissonsBot(object): def __init__(self, index): self.index = index self.mean = 2 self.roundsleft = 1000 def select(self): self.roundsleft = max(self.roundsleft-1, 2) return max(min(poisson(self.mean),10),1) def update(self, choices): myval = choices[self.index] nequal = len([c for c in choices if c==myval]) nless = len([c for c in choices if c<myval]) step = math.log10(self.roundsleft) if nequal > 1: self.mean += nequal/step self.mean -= nless/step self.mean = max(self.mean, 0.3) ``` [Answer] # MinWin Keeps a running count of the winning values and the minimum unselected values (where the minimum unselected value is only considered if it is less than the winning value). It randomly selects among these winning and minimum values. ``` import random class MinWin: def __init__(self, index): self.index = index self.mins = list(range(1, 11)) self.wins = list(range(1, 11)) def select(self): return min(random.choice(self.mins), random.choice(self.wins)) def update(self, choices): counts = [0] 10 for x in choices: counts[x - 1] += 1 if 0 in counts and (1 not in counts or counts.index(0) < counts.index(1)): self.mins.append(counts.index(0) + 1) if 1 in counts: self.wins.append(counts.index(1) + 1) ``` [Answer] # PlayerCycle Cycles through the players. Current player (could be self)'s choice is now this bot's choice. Starts out printing 8, because why not. Sorry I can't python, this is probably bad code. ``` import itertools class PlayerCycle(object): def __init__(self, index): self.a = itertools.cycle(range(10)) self.b = 8 def select(self): return self.b def update(self, choices): self.b = choices[next(self.a)] ``` Edit: Thanks to Triggernometry for improving my code with itertools [Answer] # Raccoon Choose the lowest number not chosen in the previous round, except our own previous choice, which could be chosen again this time. In the first round, choose 1. (Given 9 opponents and 10 choices, there is guaranteed to be one available value.) I came up with this independently, but now see at least 2 previous bots that are essentially the same. ``` class Raccoon(object): def __init__(self, index): self.index = index self.last_round = None self.domain = None def select(self): # Return the lowest number not chosen last time. if self.domain is None: return 1 else: # This finds the smallest element of domain, not present in last_round return min(self.domain-self.last_round) def update(self, choices): last_round = choices[:] last_round[self.index] = 0 # don't include our own choice self.last_round = set(last_round) if self.domain is None: self.domain = set(range(1,len(choices)+1)) ``` # Raccoon Triangle Combines Raccoon and Triangle: from the unchosen values, choose one based on reverse triangle probability. ``` import random class RaccoonTriangle(object): def __init__(self, index): self.index = index self.unchosen = set([1,]) self.domain = None def select(self): # Return the lowest number not chosen last time. if self.domain is None: return random.randint(1,self.index+1) else: # Reverse triangle weights for unchosen values weighted_choices = [u for i,u in enumerate(sorted(self.unchosen),0) for _ in range(len(self.unchosen)-i)] return random.choice(weighted_choices) def update(self, choices): last_round = choices[:] # make a copy last_round[self.index] = 0 # don't include our own choice if self.domain is None: self.domain = set(range(1,len(choices)+1)) self.unchosen = self.domain - set(last_round) ``` [Answer] # The General The General always fights the last war(s). ``` import numpy import random class TheGeneral: def __init__(self, index): self.round = 0 self.index = index self.would_have_won = [0] * 10 def select(self): if self.round <= 100: return random.choice((list(numpy.nonzero(self.would_have_won)[0]) + [0, 1])[:2]) + 1 return random.choice(numpy.argsort(self.would_have_won)[-2:]) + 1 def update(self, choices): for i, s in enumerate(numpy.bincount([c - 1 for i, c in enumerate(choices) if i != self.index], minlength=10)): if s == 0: self.would_have_won[i] += 1 elif s == 1: break self.round += 1 ``` [Answer] # No-Repeat Random ``` import secrets class NoRepeats(object): def __init__(self, index): self.lastround = secrets.randbelow(10) + 1 def select(self): i = secrets.randbelow(10) + 1 while i == self.lastround: i = secrets.randbelow(10) + 1 self.lastround = i return self.lastround def update(self, choices): pass ``` Bot picks randomly, but avoids picking the same number it did the previous round. ]
[Question] [ Pick a quote or phrase that is exactly 5 words long, such as `Programming puzzles and code golf!`. Write a program that, when appended to itself n times, outputs the first n + 1 words of your phrase in order. For example, if your program code was `MYPROG` and your phrase was `Programming puzzles and code golf!`, running... * `MYPROG` should output `Programming` * `MYPROGMYPROG` should output `Programming puzzles` * `MYPROGMYPROGMYPROG` should output `Programming puzzles and` * `MYPROGMYPROGMYPROGMYPROG` should output `Programming puzzles and code` * `MYPROGMYPROGMYPROGMYPROGMYPROG` should output `Programming puzzles and code golf!` Appending more than 4 times is undefined, your program may do anything. # Rules * Your phrase must be grammatical meaningful English. Ideally it should be properly capitalized and punctuated. * Your phrase may be any length but its entropy, as calculated by <http://www.shannonentropy.netmark.pl/>, may not be less than 3.5. (Paste in your phrase, hit Calculate and look for the last H(X).) * Your phrase can only contain [printable ASCII characters](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters) (hex 20 to 7E). Your code can only contain printable ASCII and tabs and newlines. * Your phrase must contain exactly 5 unique words and 4 spaces. All non-spaces count as parts of words. Spaces are the word boundaries. They may not be leading or trailing; there should be one after all but the last word. * The output should contain one space between words as well. The output at each appending step may contain trailing spaces but not leading spaces. * Output to stdout. There is no input. # Scoring Your score is the length in bytes of your initial un-appended program. (e.g. `MYPROG` scores 6) As this is code-golf, the lowest score wins. [Answer] # Piet (honorary answer) ![enter image description here](https://i.stack.imgur.com/CPsxU.png) Snakes its way downwards, running out the right through blue and re-entering through green. Prints out ["Fruit flies like a banana."](https://en.wikipedia.org/wiki/Time_flies_like_an_arrow;_fruit_flies_like_a_banana) I used [PietCreator](https://github.com/Ramblurr/PietCreator/downloads) to make this, but you can try it out [here](http://wonderfl.net/c/xYU5/fullscreen). Remaking Piet programs is a pain, so I started out at 35x35 and continued that way, meaning that I used a lot more codels than I needed. ## Actual size versions ![enter image description here](https://i.stack.imgur.com/hEMsq.png) ![enter image description here](https://i.stack.imgur.com/yJQjt.png) ![enter image description here](https://i.stack.imgur.com/EOVRh.png) ![enter image description here](https://i.stack.imgur.com/mjCaQ.png) ![enter image description here](https://i.stack.imgur.com/39qiM.png) [Answer] # [><>](http://esolangs.org/wiki/Fish) (42) Fish are truly the greatest pet. Some people keep bugs as pets due to an incomprehensible lack of logic. This program does its best to reason with such people. ``` !v'?od gub yna nac tahW;'00p! <<\|ov! voo < ``` Note there this is no trailing newline in the program. The full output is reversed in the first line; the complete phrase is "What can any bug do?" (entropy 3.58418). Full explanation: This is one of the more fun ><> programs I've written, since this is the first that uses reflection. The first line is where the meat of the program is. `!v` is a no-op, as `!` causes the next instruction to be skipped. `'?od gub yna nac tahW;'` stores the full phrase on the stack (it's backwards because each letter is pushed onto the stack in the order written, so it must be reversed to be popped off nicely). `00p` is where the real magic starts happening. Note that it didn't just store the phrase, it also stored a `;`. `00p` inserts the top character onto the stack into the program at position (0, 0), so now the first character of the program is a `;`. The ending `!` skips that semicolon, and moves the cursor onto `v`, which directs the program flow downwards. From here on out, it's all just printing routines. Since there's no trailing newline, successive appendings of the program simply add the last two lines, in effect, since the first line will be to the right of `voo <`, and thus will never be executed. At the end, the cursor is directed out the bottom left of the program, and wraps back around to the top left, where the `;` was inserted earlier, ending the program. [Answer] ## Python 66 ``` i='i'in dir()and i+1;print("Tfpcfhaialetgny"[i::5],end=" ."[i>3]); ``` Entropy: 3.61635 Ouput: ``` The fat pig can fly. ``` Thanks @JasonS and @grc for the tips on shortening the variable detection part. Update: Do see [JasonS' answer](https://codegolf.stackexchange.com/questions/35656/program-your-favorite-phrase/35666#35666) for a wicked wraparound trick which pushed this down to 55 bytes. :) [Answer] # Python 2 (37) After Sarah became president of her local Mensa chapter, she became a focus of romantic attention from men looking for an intelligent partner. On every date, Sarah would try to make a personal connection, but the men would just probe her on abstruse philosophical questions. Frustrated that nobody cared about her emotional side, she exclaimed ... ``` i=4;print"mniIMeosQy!t"[i::5],;i-=1;i ``` Output: ``` My My IQ My IQ is My IQ is not My IQ is not me! ``` The entropy is `H(x)=3.5` exactly. Credit to Jason S., [whose answer](https://codegolf.stackexchange.com/a/35666/20260) I basically used wholesale. The `ii` wraparound trick is wonderful. [Answer] # Python 3, 55 (bonus 67) ``` # 55 bytes, H(X)=3.72, Based on bitpwner's 66. "Mix dog and cat fur." i=0;print("Mdacfionauxgdtr"[i::5],end=" ."[i>3]);i+=1;i # 67 bytes, H(X)=4.28. "Thanks for supporting Python development." q=b"qx!%%0077C";a,b,q=q;print((str(credits)2)[49:][a:b],end='');q # 60 bytes, H(X) = 3.51. "Fix the bed old pal" s="Fixthebedoldpal";a,b,c,s=s;print(a+b+c,end='. '[s>[]]);s ``` You mean it wraps around? OK, some explanation on #2 (spoilers)* * `credits` is a python builtin that contains text I'd like to use. It's of a special type with a formatted `repr` so that you can just type it in the interactive interpreter and see nice output, so I have to `str()` it. I spent quite a bit of time looking at builtins for this, and "Thanks for supporting Python development" as a phrase was too good to pass up. * Since there's a lot of text and I only want my 5 words, I want to store the start and end positions of each substring. That's in the bytes at the beginning. `bytes` objects in python3 act like arrays of integers when you use sequence operations on them. * But the code can contain only printable characters, so I had to find an offset (49) that would make all my position values printable as characters. * "Thanks" is near the beginning of the string while the other words are nearer the end, which means my position values were too far apart to all be in the printable range. Mulitplying the string by 2 makes another copy of "Thanks" that is nearer to the other words. * Taking the `[49:]` slice of the string is one fewer source byte than adding 49 to both a and b. * The construct used in all three answers is `x=<value>;dostuff and increment;x`. The trailing `x` doesn't do anything at all, but when combined with the next copy of the code it turns into `xx=<value>` which prevents the `x` counter from being overwritten. * `a,b,q=q` is perfectly normal Python 3 sequence unpacking. [Answer] # C - 65 Comment abuse :) ``` charz="Ah, \0the \0good \0ol' \0times!"; for(printf(z);z++;);// ``` Because of this, the new lines are important and the code should be appended as follows: ``` char z="Ah, \0the \0good \0ol' \0times!"; for(printf(z);z++;);//char z="Ah, \0the \0good \0ol' \0times!"; for(printf(z);z++;);//... ``` [Answer] # CJam - 24 ``` "TheguywasnotI"Lm3<]S:L ``` Try it at <http://cjam.aditsu.net/> Explanation: `Lm` removes the letters contained in L (initially "") from "TheguywasnotI" `3<` takes the first 3 letters `]` collects the contents of the stack in an array `S` joins the array using space as a separator `:L` assigns the resulting string to L (also leaving it on the stack) ### Old version (28 bytes): ``` "He is but a dog."S/W):W=]S ``` Explanation: `S/` splits by space `W):W` increments W (initially W = -1) `=` gets the W'th word `]` collects the contents of the stack in an array `S` joins the array using space as a separator [Answer] # BBC Basic, 40 Includes one newline. Would be 30 if the keywords could be considered as tokenised instead of ASCII. I caught my girlfriend sleeping with the milkman, so I dumped her and I am sleeping with her sister out of revenge. `As my ex do I!` (five two-letter "words" with unique characters) wasn't enough entropy, so I added the tongue-out smiley at the end to make the entropy exactly 3.5. After all, in reality I have a fairly normal life, not some weird soap opera plot. ``` READa$:PRINTa$;" "; DATAAs,my,ex,do,I:-P ``` Repeating the program 5 times we get ``` READa$:PRINTa$;" "; DATAAs,my,ex,do,I:-P READa$:PRINTa$;" "; DATAAs,my,ex,do,I:-P READa$:PRINTa$;" "; DATAAs,my,ex,do,I:-P READa$:PRINTa$;" "; DATAAs,my,ex,do,I:-P READa$:PRINTa$;" "; DATAAs,my,ex,do,I:-P ``` Only the 5 `READ` statements are executed, and the first 5 items of data are read from the first `DATA` statement. the rest of the data is redundant. Output: ``` (once) As (5 times) As my ex do I:-P ``` [Answer] # J - 42 char I could go for a shorter phrase, but why? It wouldn't be my favourite. ``` (#~1=6\|#\)&.;: :,'You multiplied 6 by 9. ' ``` This works because of J's monad/dyad duality: every verb can be invoked as a monad—with one argument to its right—or as a dyad—with an argument on the left and another on the right. Consider the following session with the J REPL: ``` 'You multiplied 6 by 9. ' You multiplied 6 by 9. 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' You multiplied 6 by 9. You multiplied 6 by 9. ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' NB. break into words +---+----------+-+--+--+---+----------+-+--+--+ \|You\|multiplied\|6\|by\|9.\|You\|multiplied\|6\|by\|9.\| +---+----------+-+--+--+---+----------+-+--+--+ (#\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' NB. count off 1 2 3 4 5 6 7 8 9 10 (6 \| #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' NB. mod 6 1 2 3 4 5 0 1 2 3 4 (1 = 6 \| #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' 1 0 0 0 0 0 1 0 0 0 (#~ 1 = 6 \| #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' NB. select +---+----------+ \|You\|multiplied\| +---+----------+ (#~ 1 = 6 \| #\)&.;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' NB. undo ;: You multiplied ``` There, `,` is treated as a dyad, because it is between two arguments, and `(#~1=6\|#\)&.;:` is a monad because it has no left argument. So if we had a verb that could act like `,` when dyadic and `(#~1=6\|#\)&.;:` when monadic, we'd be set. As you may have already guessed, such a conjunction exists and it looks like `:`. Monadic `f :g` is equivalent to `f`, and it is equivalent to `g` when dyadic. This solves the problem. Examples, which you can try for yourself at [tryj.tk](https://a296a8f7c5110b2ece73921ddc2abbaaa3c90d10.googledrive.com/host/0B3cbLoy-_9Dbb0NaSk9MRGE5UEU/index.html#code=%28%23~1%3D6%7C%23%5C%29%26.%3B%3A%20%3A%2C%27You%20multiplied%206%20by%209.%20%27%28%23~1%3D6%7C%23%5C%29%26.%3B%3A%20%3A%2C%27You%20multiplied%206%20by%209.%20%27%28%23~1%3D6%7C%23%5C%29%26.%3B%3A%20%3A%2C%27You%20multiplied%206%20by%209.%20%27%28%23~1%3D6%7C%23%5C%29%26.%3B%3A%20%3A%2C%27You%20multiplied%206%20by%209.%20%27%28%23~1%3D6%7C%23%5C%29%26.%3B%3A%20%3A%2C%27You%20multiplied%206%20by%209.%20%27): ``` (#~1=6\|#\)&.;: :,'You multiplied 6 by 9. ' You (#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. ' You multiplied (#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. ' You multiplied 6 (#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. ' You multiplied 6 by (#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6\|#\)&.;: :,'You multiplied 6 by 9. ' You multiplied 6 by 9. ``` And yes, the nature of the inverse of `;:` makes it so that there are no trailing spaces. Using `It is by a rope.` as the phrase gives 35 char: `(#~1=6\|#\)&.;: :,'It is by a rope.'`. We don't need the trailing space like we do for my sentence, for arcane, `;:`-based reasons. [Answer] # CJam, 24 bytes ``` "LwOtmiaKoezs"W):W>5%]S ``` If run five times, it prints Liz was OK to me. Punctuation not included, sorry. ### How it works ``` "LwOtmiaKoezs" " Push that string. "; W):W " Push W (initially -1), increment and save the result in W. "; > " Shift that many characters from the string. "; 5% " Select every fifth character, starting with the first. "; ]S* " Wrap the stack in an array and join its strings using spaces. "; ``` [Answer] # [Pyth](https://github.com/isaacg1/pyth), 32 ``` p?kqZ4d@P"It is by a rope."dZ~Z1 ``` Phrase: "It is by a rope." Entropy: 3.5 How it works: `p` means print with specified separator. The first argument, `?kqZ4d`, gives the separator. `?kqZ4d` means `k if Z==4 else d`. `k` is `''`, while `d` is `' '`. The second argument, the value to be printed, is generated by splitting (`P`) on space (`d`), and the indexing into that list (`@`) at `Z`. Finally, `Z`, which is automatically initialized to 0, is incremented by 1 (`~Z1`). [Answer] # Golfscript, 53 This one was fun. ``` {'1'-print}:puts;.'You; are; not; a; duck.'';'/\,=\1+ ``` Phrase: "You are not a duck." (which is completely true; entropy 3.5110854081804286) Explanation: The stack will start as `''` on the first "run" (since no STDIN is provided). `'1'`s are appended to this to signify how many times the code has been pasted in. ``` {'1'-print}:puts; # Hacky stuff (see below) . # Stack: '' '' 'You; are; not; a; duck.'';'/ # Initialize the array of words \, # Get the length of the string of '1's (0) # Stack: '' [words] 0 = # Stack: '' 'You' \1+ # Stack: 'You' '1' ``` Now what happens on the second run: ``` {'1'-print}:puts; # Hacky stuff (see below) . # Stack: 'You' '1' '1' 'You; are; not; a; duck.'';'/ # Initialize the array of words \, # Get the length of the string of '1's (1) # Stack: 'You' '1' [words] 1 = # Stack: 'You' '1' ' are' \1+ # Stack: 'You' ' are' '11' ``` And so on. "But," you're thinking, "how do you get the 1s to not output?" Ah, that's the fun hacky part. Golfscript implements `puts` (which is called when the program ends) like this: ``` {print n print}:puts; ``` I simply changed it to ``` {'1'-print}:puts; ``` So that the `1`s are suppressed from the final output. [Answer] ## Ruby, 50 ``` puts'The fat pig can fly.'[0..File.size($0)/12-1]# ``` This uses its own length to determine how many of the words to print. Its repeats are otherwise ignored by ending in the comment character, `#`. Phrase borrowed from [bitpwner](https://codegolf.stackexchange.com/a/35658/11333): it's very convenient having a short phrase with the same number of letters in each word. Since each word+ending is 4 characters, the formula would be, e.g. for 56-length program: `(File.size($0)/56)4 - 1`, but I can divide ahead of time, `56/4 = 14`, so `File.size($0)/14 - 1`, saving a few characters. `50` isn't a multiple of `4`, but `12` is close enough for the range needed. [Answer] # [Chip](https://github.com/Phlarx/chip), 165+3 = 168 bytes +3 for flag `-w` ``` \| ,z `Z`Z `Z \| \|ZZZ>Z>ZZZ>ZZZZ >(((((((((((((((( \|)-)))-)-)))-))))g \|)d)xx-x-)xx-))x)e \|\|b+))-x-x))-x)xc \|`v))xa(-x(x-((^d \|`.))d\| b \| b \|Z~<b( \|~Zf\| >~T\| \| \| \| ``` "I won a red suit" (3.5) (I actually haven't won any such thing) (...yet) Note the trailing newline, so the concatenated copy appears below the existing code. [Try it online!](https://tio.run/##XY47DgJBDEP7nCJlAoQToDkFVQo0zA6/jgoiZO3VZ7PQYcuvsBtP98dzDPDuw9Wrc5LAcPeS9m@civyJoKaa@TF1y6prhIWtVA29ENC2uWe5UmMi1FdOZ7GQMJFTJ2zqXrWDG2cIPh@aMGa/gsp8zDNpZtAYw94L "Chip – Try It Online") (the original) [Try it online!](https://tio.run/##7Y49DkIxDIP3nCJjA4QToJ6CKQMqfeVvY4IIWb16yYONEzA8W/4Ge/F0vd3HAG9eXKwYBwkMM8th@8Qopx8RREUiX4YuUTVxV9eZIi4nAuo69ihnik@E8ojpmNSTa0qHRliVrUgDV44QrO9qYnQ7g3Lfx5kwM2g5uZz8t5NjDH2@AQ "Chip – Try It Online") (the original, plus all four copies) This is a bit of a tangled mess. It turned out that the trickiest bit was the termination condition. (My first iteration printed the word(s), followed by an endless stream of null bytes...). ### How it works First the phrase: 12 unique characters + 4 spaces = exactly 3.5 entropies. And the code: Each copy prints the first word, then tells the copy below to print the next word. If there is only one instance, there is no second copy, so nothing except the first word is printed. If there are two copies, both will print the first word simultaneously (the bytes are OR'd together so it's fine), then only the second copy will print the second word. If all five copies are present, all will print the first word, etc, etc, and the fifth copy will print the last word by itself. The termination circuit will terminate the program as soon as all copies are not actively printing. [Answer] # Ruby, 63 ``` +1;puts"See Dick and Jane run!"[/(.?( \|!)){#$.}/]if($.+=1)==$. ``` [Answer] ## Perl, 37 ``` print qw(My IQ is not me!)[$i++].' '; ``` Similar to what comperendinous had, but taking advantage of perl's qw to save a few more characters. [Answer] # [Rebmu](https://github.com/hostilefork/rebmu) message length + 27 Were we to go with "My IQ is not me!" that would be 43. But I support this message: ``` uV?'s[S[{The}{rebellion}{against}{software}{complexity.}]]proTKsPROsp ``` Equivalent Rebol/Red: ``` unless value? 's [ s: [{The}{rebellion}{against}{software}{complexity.}] ] print/only take s print/only space ``` Rebol has 3 basic conditionals: IF, EITHER, and UNLESS. UNLESS is equivalent to IF NOT but can be more clear: "Always do the following UNLESS this condition happens to be true."* In this case the condition is that we test is to see if the symbol S has been given a value in the current context. We have to use a quote on it, because attempting to use an unquoted S in a conditional expression would evaluate it and possibly raise an error. (`value?` doesn't quote its parameter by default because you might want to have which symbol you are checking be in a variable, e.g. `sym: 's` then `if value? sym [...]` would actually check if S was defined, not SYM) Only the first paste of the program will assign the series of strings to S. Successive pastes will take a string from the head of the series and pass it to PRINT/ONLY which will print its argument without adding a line feed. (Note: PRINT/ONLY is a suggested replacement way of saying PRIN, which is being considered in Rebol 3 and Red; a print replacement is now being tested in Rebmu.) [Answer] # [AHK](https://autohotkey.com/), 44 bytes ``` i++ Send % SubStr("He is an OK ex",i3-2,3) ``` Note the newline at the end. The only clever thing here is that the string is all 3-letter words so we don't have to split anything. Instead, we just pull a substring based on `i`. Output is to the active screen as if it was typed on the keyboard. [Answer] # [Pxem](https://esolangs.org/wiki/Pxem), 0 bytes: content + 170 bytes: filename. H(X) = 3.57662 Filename: `.o.c.c.zXXOnepigcannotfly.a.o.o.o` * Content is empty. [Try it online!](https://tio.run/##jVh7V9rKFv/fTzGkkUxMQjIIisSoFL2WcxQftS4roCskQYMh4ZCgaOB89d49kyAQertuXTUzv/2c/ZiHL@Hzry9fKs6eae1aTrfYK25X7F1tZ8cq29pOudc1e5qtFUtlrVwm5Y3QiZDijPXxwAxfkKYVi7ozGQajCJ3VH2tnZ0Zdx9H70EFPTmQFfi@fZzMrGAxM3xYPVNt5Vf2x56HiQZ7k86nwZe3mm8HxOOVDynCugJFEPqYfqTpLBsqMm5v90WzcPX6/OTaKmrY9By8vvjfuzn4@1i@ur0/qNwbRW4jj46@1798eb0@uvzcumlXpfcYhA72jTj7PVhWgYRC6k2QmfU1E7v@HhDMYe2bkoPCZ8QfDCIZvwcgOh54b5fOm55ohUp6QwMdE4vgjbiYYAv0K@Xzzx9lZ/fzYqDIbmNqz9fDZ7UU6GyPKlwKO9Rwg/otILRNqOQeGioFnH@Qh9K@mh7gc6ple6HDT6TKNqWbSk2no2EgI1Yn6ruoh/PpQBabwA3WoEOMCnrmohUUcQBJqPlJeozGZRiOk1EPUbmnKXgcJrba/1RGmTyNniAqJcvWhtMOrcbWm8129qattn80vwdxDodD2VVXv1vRZMm09UD2EFHl1qOrRMljR1jFCCK8GGXB3bx0jBKT9LGNlHSNamVfdLOP2OrYHfI9ZDCxbGWxndx0jBITD7Pq21zFCwMXXLOPOOkY0iFgv67a2jhENIuZkfdxbxwgp8eooa7q4jhEC0m9Zxt11jBTBn0mWsbKOkSL4@J5l3FvHSBH8@cgmQfsNBu6Y2UWX1zFCILZR1nJpHSMauDPIxnt3HSMauGNnTVfWsRKkX8pi4KKSwbaBL5fFwGs@i4EzmxSbCVNsmel2YYtpU7J@VeNT2pQT3Yb@O6XSbVxoi23c9unvwlZb5NX2drvYJipwhWphC7p1strfVU/nc7Haepu8f5h2R83FTb3rgcKZ/g7NriJVV1sPKZWWOK8iW13RofhISM23Ho7kDtgFD3ArGYILxSNEXXhOeRIcFbaAxDxLrMN6hsxNXpUp2gUXIMUxzHJxCKOaOtS7V4AmbPIRKPhktD8ZbfV4zrjCNqekcaiOdD5OzB0hqhq2OMaNanMkqrHQ8rkmUNp@CykfnS2baotGSwgsicWnkyxWZSQT2IYsp8nizERqBt5Wrz5VFphv0VVmz03j8Q0ic1yDuEzS5LLILuKWxOc01cT@J64knqRZ/52ggOZHx1JCVLeHPbPreIbBtQknxmwluDUMfPfRCl97zigaSDl@U@lQ7jbBoq4@JTy0HtsxkdszSrrEbZLSzGWXwnEXczQhnEylD2HMVbkjTmZmxVlqcJX/T8zHvNodOeYLm0DeapjzgmCI/CBCAzOynl3/iQNWYb5cCYtqFxOR@aawiZLOcmymJRMeJv/MJ5tsQtmgGVkjCr1glMYKPNJ1MRb0zy4VZoIo/nr8T7N2fmIIhaBgwc/H3d2F7wzdJ8v0wbue914wgQQ/SNhIWDdAKXpErg/3gSLaRiVU1pEdbCCU0DmefflEM7dhB76zUb9o3pw0bwxB2MDDketHPTTnS0nc9M1CiiXCBeBXOLIM4evJaaMZQ7Kl0HFsMRzBxQyz4aw39q3IDXx0iY/F@HvrRf4bix3jWIdhR5IW9BMsxiMnGo98lJOAZ0H5a0EB/IAsKH8vKFTdgnCzQqAmFbJEvsPXYnxtABdzQ1H0lPl6wTPGdTFm60f1BXqKr@X7T91w8fRc3znQDnmtqiw59i0xwBOdFdwDq2YJ6o7jxBUIJdC6@R/U/Ng3lmzX8Pnco/MpB8UB8aeXWzdCS6aHsPS3Z9dzcA5CKgbLkYRJDOB0OsZ3QFsQfNyQb@Vj2RNpFplgfGsAj@4ZnuM/Rc/4VtRpiTbghtzYNzxdHGN8bMBawmiEb@WGJMlEFP/l2Lq4w2OpVKmWyuJsYcQF65f4dMXwIz6X6/K9/FOMzw2u8FhFTWg0E9mO5Q7gxgqLdZ6cEXyH44jT6waI6/fgA/WFdgm4W9rdr@fz9f1yRWStqwNW/5d7KLW2yx0edp17o1RS6qlw0t3AgiuJGClBQOqGsV0U44QFHhOR64@dGY04Za3vlyrAc1DeFSmUGF@YTTSLPw38U0R1pVTRafb0S3y/9XNprdY8@pf4ZiUI4Zxwt5ysV8hJX74V44ahMYt9g9UxhL9Py1buK0rHuKWJorNGh4GQhw6b9ztLoR8tTENEMetPcYvWwJLBt0XTrHszwVcys5WDdqQRzsHsipXIrXG1T3lT2duF0PsfhQ5@L/Tx6QaVYm4oK65E88U8Q@8aK6QBkF7ofgdvrUtM6UvELjYhoEmJ/0Ur/BKbhyAumTQS1bs0Ivpix9gyiFLcwua@Jm7RnMF3Kaj/ZPX10465SxeL@1ueCBUDZrjCJhw1BahGrorunRHcvNxXNwQ1HC0UmhTzsH/gHfY3vaq32a@yscrGkKNZssOCZ4bWgXKA52Fmb@amlsgJC@d6EIkVrs@9e/259ofXmpEcc8ndAq5ucOzRV7My8l/I1BrDyBaQgJRecX4ewlXoEudF@mxccsdhxZycszEULivoF0nSJam/j@kmTIsWQp6Ev59OYSDqv18GXa7teA68rCHP0Arp9gQNIkmNfRCXSNIS7KRpMI0SgT5JNn0pmXdmgk5PKvonBbh8WYj92WFMOyQY0Ec0gKM1cBFDu4SUZmmFYTrFQ3jQ1wI0dG3ZidyBIw@t4Vh@DT9024wccTkHpT8/mVFkuh5ciEtLAaaX8rhCL0bs@iVMzbcX0IVMQymS0m6psr1TqiAhNiWD12YnzeP01DDhGsFt/N/5T7Wm0aEfDhIABz7HSAKvwa0O/nEoTNKDuc2Ak3lNFKYTc/QEMWhMUJq5yQb69V8 "ksh – Try It Online") ## How it works * First `.o` pops to output, if any * `.c.c.zXXOnepigcannotfly.a` is done if and only if stack is empty. * `.o.o.o` to pop top three to output. * A space at last to push a space. [Answer] # Batch 160 bytes H(X) = 3.61437 ``` @Set s=Get out by Six pm. @Set/ai+=0&Set "n=0"&Set "_=%s: ="&Cmd/Von/C "if !n!==!i! Echo(!_!"&Set/An+=1&Cmd/Von/C"if !n!!i!==44 Echo(pm."&Set "_=%" @Set/ai+=1 ``` * Split string on whitespace , match split instance count `n` with execution instance count `i` to output word. * As a result of substring parsing, the 5th instance will never match during substring modification, so a 0 index is used and the final 'word' of the phrase is output on the 5 instance by matching `i = n = 4`. Note: requires a fresh cmd instance to execute between runs when appending the code, as otherwise variable values will persist and affect the output - Alternately, execute the following command in cmd.exe to reset the variables: `set /a i=n=0` [Answer] # [Japt](https://github.com/ETHproductions/japt) [`-S`](https://codegolf.meta.stackexchange.com/a/14339/), 17 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) Includes unprintables between the backticks. ``` `âK0dÊŠ…`ò3 ¯°T) ``` [Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVM&code=YOIASzBkyoqFYPIzIK%2bwVCk), [repeated 5 times](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVM&code=YOIASzBkyoqFYPIzIK%2bwVClg4gBLMGTKioVg8jMgr7BUKWDiAEswZMqKhWDyMyCvsFQpYOIASzBkyoqFYPIzIK%2bwVCBg4gBLMGTKioVg8jMgr7BUKQ) ``` `...`ò3 ¯°T) `...` :Compressed string "thecatandhishat" ò3 :Partitions of length 3 ¯ :Slice from index 0 to °T : Prefix increment T, initially 0 ) :End slice :Implicit output joined with spaces ``` [Answer] ## Javascript (53) I took the text from aditsu as I'm not doing anything fancy with the text, so that the words chosen are somewhat irrelevant for the solution (except for byte count). ``` var i=i\|0;alert("He 0is 0but 0a 0dog".split(0)[i++]); ``` Does `alert` count in this case? Edit: Reading the rules it probably doesn't as I'm not joining the strings with spaces. I'll add spaces to make it fair. Also note that the expensive `var` is actually relevant in this case. [Answer] ## Perl, 43 ~~56~~ ``` print substr'Mine was not Red 5!',4$i++,4; ``` I accept that I can't win this one. My original attempt explains why: ``` @a=('This',' code',' is',' too',' long.');print$a[$i++]; ``` [Answer] ## Lua, 77 A pretty simple solution: ``` i=(i or 0)+1;io.write((i==1 and""or" ")..("Thebigfoxwasup."):sub(3i-2,3*i)) ``` (H(X)=4.23) [Answer] ## Javascript, 138 ``` g=this;clearTimeout(g.t);g.i\|=0;i++;g.t=setTimeout( function(){console.log(["I'll","sleep","when","I'm","dead."].slice(0,i).join(' '))},0); ``` (the additional newline is added for readability only) Prints `I'll sleep when I'm dead`. Uses a timer to make sure the output is only printed once [Answer] # Pure Bash, 51 bytes ``` a=(All you need is Love!) printf "${i:+ }${a[i++]}" ``` H(X) = 3.59447 This could be golfed down a bit more by poaching one of the shorter phrases, but I'm happy to stick with Descartes' Lennon's most famous quote. (Sorry @Descartes, but all words need to be unique). ### Output: ``` $ ./phrase.sh All$ cat phrase.sh phrase.sh phrase.sh > phrase3.sh $ chmod +x phrase3.sh $ ./phrase3.sh All you need$ $ cat phrase.sh phrase.sh phrase.sh phrase.sh phrase.sh > phrase.sh $ chmod +x phrase5.sh $ ./phrase5.sh All you need is Love!$ ``` Takes care to insert spaces between words, but no leading or trailing spaces. Relies on the fact that in bash, undefined variables, when expanded as strings have the value "", but when expanded arithmetically have the value 0. [Answer] # PHP 89 78 char Its a little verbose, and most definitely won't win, but it was fun anyway. Here's what I came up with Phrase: `code golf is pretty fun` Entropy = 3.82791 Code: ``` <? $i=(isset($i)?$i+1:0); $w=["code","golf","is","really","fun"]; echo $w[$i]."; ``` Golfed: ``` <?$i=(isset($i)?$i+1:0);$w=["code","golf","is","really","fun"];echo $w[$i]. ``` [Answer] # Python3 - 122 bytes ## Open the pod bay doors [HAL] I guess I'll earn some nerd cred with this one. If only the question would allow one more word... What my program does is takes the filename (p.py is the base) and checks how many times the base name is iterated. It then takes slices from a string `n` times. `n` being the number of `p`s in the filename. ``` import sys,re for i in range(len(re.findall(re.compile('p'),sys.argv[0]))):print('Otpbdphoaoeedyon r s'[i::5],end='') ``` --- ``` ~ $ python p.py Open ~ $ python pp.py Open the ~ $ python ppp.py Open the pod ~ $ python pppp.py Open the pod bay ~ $ python ppppp.py Open the pod bay doors ``` The benefit of the regex is that the program can be called whatever you like and it will still work (providing you change the basename in the code): my original program was called golfed.py. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 21 bytes (Noncompeting) ``` “€Œ‰‹€‡Øš‹É.“ª#¾è¼?ð? ``` [Try it online!](https://tio.run/##MzBNTDJM/f//UcOcR01rjk561LDhUcNOIPNRw8LDM44uBHIOd@oBZQ@tUj607/CKQ3vsD2@w//8fAA "05AB1E – Try It Online") Uses: ``` This works for literally anything. H(x) = 4.02086 ``` ### Explanation ``` “€Œ‰‹€‡Øš‹É.“ª#¾è¼?ð? “€Œ‰‹€‡Øš‹É.“ª # Pushes "This works for literally anything." # # Split on spaces ¾è # get element at index of counter_variable (default 0) ¼ # Increment the counter_variable ? # Print the selected element ð? # Prints a space ``` [Answer] # [Stax](https://github.com/tomtheisen/stax), 24 ``` `nH+~mJp@Z_Iy.5!`j\|d:/dJ ``` [Run and debug it](https://staxlang.xyz/#c=%60nH%2B%7EmJp%40Z_Iy.5%21%60j%7Cd%3A%2FdJ&i=) Quote: Some animals are more equal. ]
[Question] [ Given a number `N`, output a NxN right angled triangle, where each row `i` is filled with numbers up to `i`. Example n = 0 (no output) n = 4 ``` 1 1 2 1 2 3 1 2 3 4 ``` n = 10 ``` 1 1 2 1 2 3 . . . 1 2 3 4 5 6 7 8 9 10 ``` (no alignment needed) n = N ``` 1 1 2 1 2 3 . . . 1 2 3 4 .... N ``` There is no trailing space at the end of each line. Least number of bytes wins, and standard loopholes are not allowed. [Answer] # [Joe](https://github.com/JaniM/Joe), 5 3 bytes (+2 or +3 for `-t` flag) Well, apparently I didn't utilize the full potential of Joe. This was possible back when I first posted this. ``` \AR ``` Here, `R` gives the range from 0 to n, exclusive. Then `\A` takes successive prefixes of it (`A` is the identity function). Examples: With `-t` flag (note: this is now the standard output even without the flag): ``` (\AR)5 0 0 1 0 1 2 0 1 2 3 0 1 2 3 4 \AR5 0 0 1 0 1 2 0 1 2 3 0 1 2 3 4 \AR2 0 0 1 \AR1 0 \AR0 ``` Without it: ``` \AR5 [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]] (\AR)5 [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]] \AR2 [[0], [0, 1]] \AR1 [[0]] \AR0 [] ``` --- The rules got changed a bit. My old code didn't behave correctly with N =0. Also, now output could be just a nested list, so `-t` can be dropped. ``` 1R1+R ``` Now, `Rn` gives a range from 0 to n, exclusive. If given 0, it returns an empty list. `1+` adds 1 to every element of that range. `1R` maps the values to ranges from 1 to x. Empty liats, when mapped, return empty lists. Example output: ``` 1R1+R0 [] 1R1+R5 [[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]] ``` Update: I just noticed something. The function automatically maps to rank 0 elements. The following example is run with `-t` flag. ``` 1R1+R3 5 8 1 1 2 1 2 3 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 1 2 3 4 5 6 1 2 3 4 5 6 7 1 2 3 4 5 6 7 8 ``` --- Old: 5 bytes (with the `-t` flag) ``` 1R1R ``` This is an anonymous function which takes in a number, creates a list from 1 to N (`1Rn`) and maps those values to the preceding range, giving a range from 1 to x for each item of range 1 to N. The `-t` flag gives output as a J-like table. ``` 1R1R5 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 ``` Note : the language is very new and not complete, but the latest version was released before this challenge. [Answer] # Python 3, ~~48~~ 45 bytes ``` f=lambda n:n and[f(n-1),print(range(1,n+1))] ``` Hooray for side effects. [Answer] ## APL, 5 ``` ⍪⍳¨⍳⎕ ``` creates a vector 1..n and for each element another such vector. Then ⍪ makes a column out of all vectors. This avoids the problem with trailing blanks. Try it on [tryapl.org](http://tryapl.org/?a=%u236A%u2373%A8%u23734&run) --- Older solution: ``` {⎕←⍳⍵}¨⍳⎕ ``` Creates a vector 1..n {⎕←⍳⍵} is a function that outputs for each (¨) element a vector 1..n on a separate line This one can't be tried on tryapl.org unfortunately, because ⎕← doesn't work there. [Answer] # J, 27 bytes J is not good with non-array numeric output. This function creates a properly formatted string from the numbers. ``` ;@(<@,&LF@":@:>:@:i.@>:@i.) (;@(<@,&LF@":@:>:@:i.@>:@i.)) 4 1 1 2 1 2 3 1 2 3 4 ``` [Try it online here.](http://tryj.tk/) [Answer] # PHP, 53 Bytes Edit 2: [Ismael Miguel](https://codegolf.stackexchange.com/questions/47657/print-number-triangle/47688#comment112221_47688) suggested reading from input instead of defining a function, so the score is now 53 bytes for PHP: ``` for($a=1;@$i++<$n=$argv[1];$a.=" ".($i+print"$a\n")); ``` And once again, it can be improved if PHP is configured to ignore errors (52 bytes): ``` for($a=1;$i++<$n=$argv[1];$a.=" ".($i+print"$a\n")); for($a=1;$i++<$n=$_GET[n];$a.=" ".($i+print"$a\n")); ``` --- Edit: [Austin](https://codegolf.stackexchange.com/questions/47657/print-number-triangle/47688#comment112085_47688) suggested a 60 bytes version in the comments: ``` function f($n){for($a=1;@$i++<$n;$a.=" ".($i+print"$a\n"));} ``` Which can be improved if we doesn't display PHP errors (59 bytes): ``` function f($n){for($a=1;$i++<$n;$a.=" ".($i+print"$a\n"));} ``` `$a` stores the next line that will be printed, and each time it's printed a space and the next number ([`print`](http://php.net/print) always returns `1`) are concatened to it. --- Recursive functions (65 bytes): ``` function f($n){$n>1&&f($n-1);echo implode(' ',range(1,$n))."\n";} function f($n){$n>1&&f($n-1);for(;@$i++<$n;)echo$i,' ';echo"\n";} // Using @ to hide notices. ``` Shorter recursive function, with error reporting disabled (64 bytes): ``` function f($n){$n>1&&f($n-1);for(;$i++<$n;)echo$i,' ';echo"\n";} ``` Even shorter recursive function, with error reporting disabled and an empty line before real output (62 bytes): ``` function f($n){$n&&f($n-1);for(;$i++<$n;)echo$i,' ';echo"\n";} ``` --- Just for fun, non-recursive fucntions: ``` function f($n){for($i=0;$i<$n;print implode(' ',range(1,++$i))."\n");} // 70 bytes function f($n){for(;@$i<$n;print implode(' ',range(1,@++$i))."\n");} // 68 bytes, hiding notices. function f($n){for(;$i<$n;print implode(' ',range(1,++$i))."\n");} // 66 bytes, error reporting disabled. ``` [Answer] # CJam, ~~13~~ 12 bytes ``` ri{),:)SN}/ ``` How it works: ``` ri{ }/ "Run the block input number of times with iteration index from 0 to N-1"; ) "Increment the iteration index (making it 1 to N)"; , "Get an array of 0 to iteration index"; :) "Increment each of the above array members by 1"; S* "Join all above array numbers with space"; N "Add a new line. After all iterations, things are automatically printed"; ``` [Try it online here](http://cjam.aditsu.net/#code=ri%7B)%2C%3A)SN%7D%2F&input=5) [Answer] # Pyth, 9 bytes ``` VQjdr1hhN ``` Really thought that this can be done shorter, but it doesn't seem so. Try it [online](https://pyth.herokuapp.com/?code=VQjdr1hhN&input=5&debug=0). ``` Q = input() VQ For N in [0, 1, ..., Q-1]: r1hhN create list [1, ..., N+1+1-1] jd print joined with spaces ``` [Answer] # JavaScript (ES6) 49 ~~52~~ Such a simple task, I wonder if this can be made shorter in JS (Update: yes, using recursion) Recursive 49 ``` f=n=>alert((r=w=>n-i++?w+'\n'+r(w+' '+i):w)(i=1)) ``` Iteraive 52 ``` f=n=>{for(o=r=i=1;i++<n;o+='\n'+r)r+=' '+i;alert(o)} ``` [Answer] # Java, ~~85~~ 84 bytes This is surprisingly short in Java. ``` void a(int a){String b="";for(int c=0;c++<a;System.out.println(b+=(c>1?" ":"")+c));} ``` Indented: ``` void a(int a){ String b=""; for(int c=0; c++<a; System.out.println( b+=(c>1?" ":"")+c )); } ``` 1 byte thanks to Bigtoes/Geobits [Answer] # Prolog - 119 ``` h(N):-setof(X,(between(1,N,K),setof(Y,between(1,K,Y),X)),[L]),k(L),nl,fail. k([A\|B]):-write(A),(B=[];write(" "),k(B)). ``` [Answer] Python 2 - ~~62~~ ~~54~~ 65 bytes* ``` def f(n): for x in range(n):print' '.join(map(str,range(1,x+2))) ``` [Answer] ## J, 9 characters As a tacit, monadic verb. ``` [:":\1+i. ``` * `i. y` – the numbers from `0` to `y - 1`. * `1 + i. y` – the numbers from `1` to `y`. * `": y` – the vector `y` represented as a string. * `":\ y` – each prefix of `y` represented as a string. * `":\ 1 + i. y` – each prefix of the numbers from `1` to `y` represented as a matrix of characters. [Answer] # [><> (Fish)](http://esolangs.org/wiki/Fish), 40 37 + 3 = 40 bytes ``` &1>:&:&)?;1\ (?v:n" "o1+>}:{:@ ao\~1+ ``` Once again, ><> does decently well at another number printing exercise. Run with the `-v` flag for input, e.g. ``` py -3 fish.py -v 4 ``` ## Explanation ``` & Put n in register 1 Push 1 (call this "i") [outer loop] :&:&)? If i > n... ; Halt 1 Else push 1 (call this "j") [inner loop] }:{:@(? If j > i... ~1+ao Pop j, print newline, increment i and go to start of outer loop :n" "o1+ Else print j, print a space, increment j and go to start of inner loop ``` [Answer] # Python 2 - 72 ``` >>> def p(N):print'\n'.join(' '.join(map(str,range(1,i+2)))for i in range(N)) ... >>> p(5) 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 ``` [Answer] # Perl, 28 Reads the parameter from stdin. ``` @x=1..$_,print"@x "for 1..<> ``` From the command line: ``` perl -E'$,=$";say 1..$_ for 1..<>' ``` but I don't now how to count that (probably between 25 and 29). [Answer] # C (with no loops, yeah!) - 72 bytes ``` b(n,c){if(n){b(n-1,32);printf("%d%c",n,c);}}r(n){if(n){r(n-1);b(n,10);}} ``` This creates a function `r(n)` that can be used this way: ``` main(){ r(5); } ``` See it in action, here [on tutorialspoint.com](http://www.tutorialspoint.com/compile_c_online.php?PID=0Bw_CjBb95KQMUXFpbmVERldCTmM) It requires a very few tricks easily explained. I think it can be greatly improved. [Answer] # [Thunno 2](https://github.com/Thunno/Thunno2) `N`, 5 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md) ``` RRıðj ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faGm0kp9S7IKlpSVpuhbLg4KObDy8IWtJcVJyMVRswSJDAwgLAA) #### Explanation ``` RRıðj # Implicit input -> 4 R # Range [1..n] -> [1,2,3,4] R # Range of each -> [[1],[1,2],[1,2,3],[1,2,3,4]] ı # To each list: ðj # Join by spaces -> ["1","1 2","1 2 3","1 2 3 4"] # Join by newlines -> "1\n1 2\n1 2 3\n1 2 3 4" # Implicit output ``` [Answer] # [Julia 1.0](http://julialang.org/), 34 bytes ``` ~n=1:n.\|>x->println(join(1:x,' ')) ``` [Try it online!](https://tio.run/##yyrNyUw0rPj/vy7P1tAqT6/GrkLXrqAoM68kJ08jKz8zT8PQqkJHXUFdU/N/nYGCsoJfvkJ@aUlBaQlXnaHRfwA "Julia 1.0 – Try It Online") [Answer] ## Python ``` import string N,s=int(input()),list(string.digits) for i in range(1,N+1): print(' '.join(s[1:i+1])) ``` [Answer] # Golfscript 14 ``` ,{2+,1>' 'n}/ ``` Expects the input number to be present on the stack. Online example: [link](http://golfscript.apphb.com/?c=MTAKCix7MissMT4nICcqbn0v&run=true) [Answer] # [Clip](http://esolangs.org/wiki/Clip), 16 ``` Jm[ijkw,1iwS},1n ``` ## Explanation ``` J .- join with newlines -. m[i },1n .- map numbers from 1 to numeric value of input -. jkw wS .- join with spaces -. ,1i .- numbers from 1 to index -. ``` [Answer] # Go, ~~93~~ ~~81~~ ~~78~~ ~~93~~ 90 bytes ``` func r(n int)(s string){s=string(n+48);if n!=1{s=r(n-1)+" "+s};println(s);return} ``` ## Current ungolfed ``` func r(n int) (s string) { // Convert n to a string, we do not have to initialize s since // we hijacked the return value. // Numbers in the ascii table starts at 48 s = string(n \| 48) // Unless we are on our last iteration, we need previous iterations, // a space and our current iteration if n != 1 { // Collect the result of previous iteration for output s = r(n-1) + " " + s } println(s) // We can use a naked return since we specified the // name of our return value in the function signature return } ``` If we need to handle N > 9 we can use the following at 78 bytes, however it requires importing the `fmt` package. ``` func r(n int)(s string){s=Sprint(n);if n!=1{s=r(n-1)+" "+s};Println(s);return} ``` If we include the import statement I'm now back at my initial ~~93~~ ~~92~~ 90 bytes ``` import."fmt";func r(n int)(s string){s=Sprint(n);if n>1{s=r(n-1)+" "+s};Println(s);return} ``` Test it online here: <http://play.golang.org/p/BWLQ9R6ilw> The version with `fmt` is here: <http://play.golang.org/p/hQEkLvpiqt> [Answer] # ZX / Sinclair BASIC - 39 bytes ZX Basic uses 1 byte per keyword (all the uppercase words), so helps to keep the byte size down a bit... ``` 1 INPUT n:FOR i=1 TO n:FOR j=1 TO i:PRINT j;" ";:NEXT j:PRINT:NEXT i ``` Using n = 8 ![enter image description here](https://i.stack.imgur.com/cjz2y.png) [Answer] # R, 28 ``` for(i in 1:scan())print(1:i) ``` [Answer] # TI-Basic, 28 bytes ``` Input N For(I,1,N randIntNoRep(1,N->L1 SortA(L1 Disp L1 End ``` [Answer] # C, 89 characters ``` // 90 characters f(int n){int a=1,b;for(;n--;++a){for(b=0;b<a;++b)printf("%c%d",(!!b)' ',b+1);puts("");}} ``` To eliminate confusion about `puts("");`. This simply prints a newline character (as seen [here](http://www.cplusplus.com/reference/cstdio/puts/)): > > Notice that puts not only differs from fputs in that it uses stdout as destination, but it also appends a newline character at the end automatically (which fputs does not). > > > I got it slightly shorter with @TheBestOne's java algorithm: ``` // 89 characters f(int a){char b[999]="",p=b+1;int c=0;for(;a--&&(sprintf(b,"%s %d",b,++c)&&puts(p)););} ``` [Answer] # Perl: 34 characters ``` print"@$_\n"for map[1..$_],1..$_; ``` This code gets the input number supplied through the special variable `$_`. [Answer] # C# - 94 bytes Written as an anonymous function that returns a string, which doesn't seem to be disallowed by the spec. ``` n=>String.Join("\n\n",Enumerable.Range(1,n).Select(l=>String.Join(" ",Enumerable.Range(1,l)))) ``` Here's an ungolfed version (comments are read in BDCA order): ``` n => String.Join("\n\n", //...then join it together with newlines. Enumerable.Range(1, n).Select(l => //For each l from 1 to n, ... String.Join(" ", //...and join it with spaces, ... Enumerable.Range(1, l) //...get the range from 1 to l, ... ``` [Answer] # Bash+coreutils, 26 bytes ``` seq $1\|sed "x;G;s/\n/ /;h" ``` `seq` simply generates the numbers 1 to n * `sed` saves the entire output for a given line in the hold space, and then appends the next line to it. [Answer] # Haskell, 62 57 bytes ``` e=enumFromTo 1 f=putStr.unlines.map(unwords.map show.e).e ``` Point-free style. Usage example: ``` Prelude> f 5 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 ``` ]
[Question] [ Imagine the following 24-hour clock that can be controlled by arrow keys: ``` ╔══╗ ┌──┐ ║00║:│00│ ╚══╝ └──┘ HH mm ``` Pressing the up arrow twice (`↑↑`) will increase the currently focused hour input: ``` ╔══╗ ┌──┐ ║02║:│00│ ╚══╝ └──┘ HH mm ``` Pressing the right arrow (`→`) will focus the other input. ``` ┌──┐ ╔══╗ │02│:║00║ └──┘ ╚══╝ HH mm ``` Pressing the down arrow thrice (`↓↓↓`) will now decrease this input. ``` ┌──┐ ╔══╗ │02│:║57║ └──┘ ╚══╝ HH mm ``` Shortly put: * The up arrow (`↑`) will increase the currently active input. * The down arrow (`↓`) will decrease the active input. * The right arrow (`→`) will move focus to the right input. * The left arrow (`←`) will move focus to the left input. * Up and down movement will loop around as expected for a time input. * Left and right movement don't loop around. ## The challenge The clock starts out at `00:00` with the hour input active (see first schematic). Given a list of input commands, output the resulting time in `HH:mm` format. Input can be either a string or a list (or your language equivalent), where the different input directions can be one of the below options: * `↑↓←→` * `udlr` * `^v<>` * actual arrow key presses if your program has a GUI Standard loopholes apply. ## Test cases ``` ↑↑→↓↓↓ = 02:57 ↓→↑←↑→↓ = 00:00 ↓→→↓ = 23:59 ←←←←→↑ = 00:01 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓→↓ = 23:59 ``` [Answer] # HTML on Google Chrome 67 in Chinese (Simplified), 39 bytes ``` <input type=time value=00:00 autofocus> ``` [![Screenshot](https://i.stack.imgur.com/R7T8x.png)](https://i.stack.imgur.com/R7T8x.png) Chrome show different UI component in different language. Even a simple time input: AM/PM will be shown if you are using English (US). If you want test this by changing your Chrome's language. Do not mass up how to change it back. [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~117~~ 107 bytes * Saved ten bytes thanks to [l4m2](https://codegolf.stackexchange.com/users/76323/l4m2). ``` t,i,m[8];e(char_){for(m=i=2[m]=0;t=_++;t<63?i=t%4:(i[m]+=t&8?1:'w'));printf("%02d:%02d",m%24,2[m]%60);} ``` [Try it online!](https://tio.run/##ZYzPDoIgAMbP9RSOjQKkzcw5J6IP4sQ50uKANSM6OJ@dsFvzO3yH3/dHnm5SOmeoorrOGtYjee8m0uJ5eEyIaK54XOuGR8xw0oYhM0V6qRQ3MMmR8knIzSGrzvnxc8SYPSc1mgEBGMXXfDVAiYZxQtcTmEaYLU53akR43u96BIQorbUg8Mu3eSEAMPtxW4rCR2DLPQyCTb/wKsX/z@K@ "C (gcc) – Try It Online") [Answer] # [Stax](https://github.com/tomtheisen/stax), ~~36~~ ~~35~~ ~~33~~ 32 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax) ``` áXò↑─↨√▓\|êóÇiU&≡Q#┤Æ⌡⌠╟C▐╜√⌡∟▄╩╠ ``` [Run and debug it](https://staxlang.xyz/#p=a0589518c417fbb27c88a280695526f05123b492f5f4c743debdfbf51cdccacc&i=uurddd%0Adrulurd%0Adrrd%0Allllru%0Adddddddddddddddddddddddddrd&a=1&m=2) Uses `lrud`. Explanation: ``` 'l/{'r/Bs$2lmM{${:14-m\|+i3624+%2\|zm': Full program, 'l/ Split the string on "l" { m Map over the resulting array 'r/ Split at "r" B Uncons left, first on TOS (top of stack) s Swap to get tail to top $ Flatten; this removes multiple 'r's 2l Listify two items, BOS (bottom of stack) is first element M Transpose: get [hour commands, minute commands] { m Map: $ Flatten { m Map over single commands: :1 Number of set bits: 5 for 'u', 3 for 'd' 4- Subtract 4: u -> 1, d -> -1 \|+ Sum i Iteration index: hours -> 0, minutes -> 1 3624+ Multiply by 36, add 24: 0 -> 24, 1 -> 60 % Modulo, this does -5 % 60 = 55 2\|z Stringify, left-padding with "0" to length 2 ': Join on ":" Implicit output ``` [Answer] # [Python 2](https://docs.python.org/2/), 105 bytes ``` h=m=p=0 for c in map(' ^<>'.find,input()):w=1/c;m+=wp;h+=w-wp;p=[c-2,p][w] print'%02d:%02d'%(h%24,m%60) ``` [Try it online!](https://tio.run/##dY3BDoMgGIPvPAUhIajTzZltBxVexIxkQQ0cwD/G4fb0DLyvh/Zr0qTw3fTimqCWceKEkKC55cBrNC8rVtg4bF@QMSx7wc6zcWNpHLy3LM/bnV8vqrMnvhfQ6RhVAuCDqpoSnsP@RLAatzFaN2ObjNFM0@ZWWvqo8xDf0PSZFE7fxT0QKYX3niDihewjH3REHyVk6v8UZz8 "Python 2 – Try It Online") [Answer] # [JavaScript (Node.js)](https://nodejs.org), 103 bytes Takes input as a string, using `udlr`. ``` s=>(Buffer(s).map(n=>n%6?s%4?m+=n%2\|\|59:h+=n%2\|\|23:s=n,h=m=0),g=n=>('0'+n).slice(-2))(h%24)+':'+g(m%60) ``` [Try it online!](https://tio.run/##fdBNDoIwEAXgvadg03QmCNYqGptUE29CKD@aUkhrXXl3rFE3KLxVk@mXN5lrfs9dYS/9LTGdKodKDk4e4eyrqrTgMG3zHow8GrI7ObI9tbE0hD8e2UE0nyffCCfNspGtZLisZfgNlNHYYOr0pSgh4YjQEL7FmAoa19CSHcOh6IzrdJnqroYKKEWMZrJaRYwJxhYj5r1VStFoQr8YF9l@zJT1Okg6w/61KRtMmE@zcI3sMGY6xPrZJUPb@qdtKu/Fv23DEw "JavaScript (Node.js) – Try It Online") [Answer] # [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 149 132 bytes ``` s=>{var p=0;int[]h={0,0};foreach(var c in s)h[p=c<63?c/2%2:p]+=c>62?c>95?-1:1:0;return$"{(h[0]%24+24)%24:D2}:{(h[1]%60+60)%60:D2}";} ``` [Try it online!](https://tio.run/##jY9Na4NAGITv/ooXaUAxH@umsWT9yKGlpxYKPfQgCrIxcSFdw@5GCOJvt2s0JD0EnMvA7LsPM1TOaCnylh4yKeHLqA3QkipTjILIs23JD2f4PkuV/87fT5wGUgnG91PoPYIdhK0Mo7rKBBxD5DOu4qQIazRFjb/T7IwWVvdIgXGQdhEfQxp4yw1d4Akmx8QJaeThDY3Wq83MJS5BvsjVSfAns7aKGCUT/OzgZ1sbecMN6UI3mXjI8ZCtrQtNv2lhkG/cb6hKtoXPjHGrLxwnkIm9tC83/dpOw8LXksvykM9/BFP5B@O5ZaZpVFUVQAgmOLC7BqZt@wCLBSBMVi8jOFWUBvrnjTMEF1DHQQShURwNAbjnDBC49MFLslqP4ARaUXrH6YPbLt3HHdPnkf5tfXx03X/r3RiN0f4B "C# (.NET Core) – Try It Online") Using `^v<>`. This one made me realize that the modulo operator in C# does not work as expected, because in C# `-1 % 60 = -1`, so I need to do that weird operation at the end. [Answer] Lua (love2d framework),311 308 bytes ``` l,b,d,t,f,a=love,{24,60},{1,-1},{0,0},1,{"left","right","up","down"}function c(n,i)t[f]=(n+d[i])%b[f]end function l.draw()h,m=t[1],t[2]l.graphics.print((h<10 and 0 ..h or h)..":"..(m<10 and 0 ..m or m),0,0)end function l.keypressed(k)for i,n in pairs(a)do f=k==n and(i>2 and(c(t[f],i-2)or f)or i)or f end end ``` Unscrumbeled version: ``` --initialize all needed values l,b,d,t,f,a=love,{24,60},{1,-1},{0,0},1,{"left","right","up","down"} --increase the numbers depending on the focus and up or down function c(n,i) t[f]=(n+d[i])%b[f] end --draw the time to the screen function l.draw() h,m=t[1],t[2] l.graphics.print((h<10 and 0 ..h or h)..":"..(m<10 and 0 ..m or m),0,0) end --get the keys and check if it is an arrow key function l.keypressed(k) for i,n in pairs(a)do f=k==n and(i>2 and(c(t[f],i-2)or f)or i)or f end end ``` Probably still not 100% easy to read because all the ifs are interchanged with an trinary statement ( ..and ..or) :) if started in an main.lua with love then it will pop up a window and you can press the arrowkeys to change the numbers [Answer] # [MATL](https://github.com/lmendo/MATL), ~~57~~ ~~56~~ 55 bytes ``` 1Oi9\"@5<?y@3-ZS+}wx7@-X^w]]wx&Zjh24 60h\'%02d:%02d'YD ``` [Try it online!](https://tio.run/##y00syfmf8N/QP9MyRsnB1Ma@0sFYNypYS7u2vMLcQTcirjw2trxCLSorw8hEwcwgI0Zd1cAoxQpEqEe6/HcJ@a8eF2dXVlamzqVeZhdnA2SDWWDKBgjs4kB8XACoDAA "MATL – Try It Online") Represents hour and minutes using complex numbers, with the real part being hours and the imaginary part minutes. ### With comments: ``` 1 % Push 1 on the stack % represents which timer box we're in, starts at hour box % imaginary number j would represent minutes box O % Push initial hour and minutes 0+0j i9\ % Fetch input, mod each character's ASCII value by 9. % Gives 4 1 8 6 for ^ v > < respectively " % iterate through (modded) input @5<? % Push current input, see if it's < 5 % if so, it's an up or down time change y % so copy out the box indicator (1 or j) @3- % Subtract 3 from the current input ZS % Take the result's sign (-1 for v, 1 for ^) % Multiply indicator with that + % Add the result to the time value } % else, it's a right or left arrow wx % so bring out the box indicator and delete it 7@- % Subtract current input from 7. 1 for < and -1 for > X^ % Take the square root of that. 1 for < and j for > w % switch stack to bring time value on top again ] % end if ] % end loop wx % bring box indicator out, delete it &Zj % split the complex time value to real and imaginary h % then concatenate them into an array 24 60h\ % mod hour and minute values by 24 and 60 respectively '%02d:%02d'YD % sprintf the time array with 0-padding ``` [Answer] # [PHP](http://www.php.net/), ~~145~~ ~~134~~ 133 bytes (-11 bytes by more golfing) (-1 byte by using [Davіd](https://codegolf.stackexchange.com/users/78488/dav%d1%96d)'s loop method) ``` <?for($h=$m=0,$a=h;$c=$argv[++$i];)$c<l?$$a--:($c>r?$$a++:$a=$c<r?h:m);$h%=24;$m%=60;printf('%02d:%02d',$h<0?$h+24:$h,$m<0?$m+60:$m); ``` To run it: ``` php -n -d error_reporting=0 <filename> <command_1> <command_2> ... <command_n> ``` Example: ``` php -n -d error_reporting=0 time_setter.php u u r d d d l d ``` Or [Try it online!](https://tio.run/##HYvbCoMwGINfZRcRlSoUES9auz7IGEM8VVgP/HN7/P3T8UFISJJcYu7tEqmAM/BGVhiM0xgNBlo/NyGw3XWJsX9aYKhrVWC80umFUMf2aMg65UsNl5mm1fCZ6aROtIV9KfJMNpM6Ja/gemnhRNMquAr@TF50UuF4M/P7gHj68@TpG9O@xfDiOnA9XWaiSA@aU6R9C6uRPw "PHP – Try It Online") Notes: * To save some bytes, I have used strings without single/double quotations as the string wrapper. Thus, the `error_reporting=0` option is used to not output warnings. * Input commands: `u d l r` [Answer] # JavaScript, ~~104~~ 103 bytes Takes input as an array of characters, using `<>^v`. ``` a=>(a.map(z=>z<"^"?a=z<">":a?x+=z<"v"\|\|23:y+=z<"v"\|\|59,x=y=0),g=n=>`0${n}`.slice(-2))(x%24)+`:`+g(y%60) ``` [Try it online](https://tio.run/##dY5NCoMwFIT3HiNUSFCD2B@o9T0PIoYEq2KxKlWCWnt2m1rorrOZ@YZZzE1p1WePqhu8pr3mawGrAqSK31VHZ8A5IoLECowjCVU8Op@oybIE@3D6wfHsjjCBz9wSGkDp757NS/K@rrKcegFjdLSDA3NkKJ2STvbJZ@sAiUWEQK01cS2iUUQGvvHrkRGKrfknM7TSy7DdrQCztunbOud1W9KCJpzzKmWMrW8) [Answer] # Haskell, 236 bytes ``` f=u 0 0 k _ _ _ _ _ h m[]=z h++':':z m k a b c d e h m(q:s)=case q of{'^'->e(a h)(b m)s;'v'->e(c h)(d m)s;'>'->v h m s;'<'->u h m s} u=k(o(+)24)id(o(-)24)id u v=k id(o(+)60)id(o(-)60)v o f m x=mod(f x 1)m z n\|n<10='0':show n z n=show n ``` `f` is the main function, and has type `String -> String`: ``` Main> f "^^>vvv" "02:57" Main> f "v>^<^>v" "00:00" Main> f "v>>v" "23:59" Main> f "<<<<>^" "00:01" Main> f "vvvvvvvvvvvvvvvvvvvvvvvvv>v" "23:59" ``` Essentially `u` and `v` are mutually recursive functions of type `Integer -> Integer -> String -> String`. They take the hour, the minute and a list of characters over the set `{v,^,<,>}`, and return the time string. `u` acts as if the hour dial is highlighted, recursively calling `u` if the head of the list is in `{v,^}`, and `v` if the head of the list is in `{<,>}`. `v` is similar but for the minute dial. Everything else is just saving characters. [Answer] # [Lua](https://www.lua.org), 132 bytes ``` loadstring's,t,m=1,{0,0},{24,60}for c in(...):gmatch"."do t[s]=(t[s]+(("d u"):find(c)or 2)-2)%m[s]s=("lr"):find(c)or s end return t' ``` [Try it online!](https://tio.run/##dU9BCsIwELz7iiUgJpiGGsRDIS@RHmLTarBNZJPiQXx7TFRED85hlt1hZnfHWadBpdFrEyJad1wFHvmkNvxW8/rOb3LLd/V98AgdWEeFEKw5Tjp2JyKI8RD3oVW08JpSYmAmrBmsM7Rj2SNZJdlyympQlIz4IwbonQHs44wO4ipZL65oY59zlrU0TaFi8Jj30agPYy9md9HdmQ7PQzIWVQUem1IQFLzmpfuEvd4S75SvZI77TZtJtiwl8w9oHg "Lua – Try It Online") --- ### Explanation This is an anonymous function (a way to use it is shown on the link). ``` s=1 -- s will control the selection (1 is hour and 2 min) t={0,0} -- is the time itself m={24,60} -- is the maximum for each 'box' (hour or min) -- I've actually used Lua's multiple variable assignment: s,t,m=1,{0,0},{24,60} for c in (...):gmatch(".") do -- go through each character of the input t[s] = (t[s] + (("d u"):find(c) or 2)-2) % m[s] -- set the current 'box' as t[s] + -- itself plus ... ("d u"):find(c) or 2 -- it's index on the string "d u" (that means it's going to be 1 or 3) -- or 2 if it wasn't found (if the current character doesn't sum or subtract from the box) -2 -- this adjusts the result 1, 2 or 3 to being -1, 0 or 1 -- making the inputs 'd' and 'u' as -1 and +1 respectively, and an input different from both as 0 ( ) % m[s] -- modulo of the maximum of the selected 'box' s=("lr"):find(c) or s ("lr"):find(c) -- if the current input character is l or r, then set 's' (the 'box' selection) to being 1 or 2. or s -- else let it as is end return t -- returns 't', a table with hour and minutes respectively ``` [Answer] # Java 8, 121 bytes ``` c->{int i=0,m[]={0,0,0};for(int t:c)if(t<63)i=t%4;else m[i]+=(t&8)>0?1:119;return"".format("%02d:%02d",m[0]%24,m[2]%60);} ``` Port of [Jonathan Frech](https://codegolf.stackexchange.com/users/73111/jonathan-frech)'s C [answer](https://codegolf.stackexchange.com/a/168794/79343). Accepts `^v<>`. Try it online [here](https://tio.run/##lZBda4MwFIav9VcEwZGw1kb7sVWrY/S6V7ssClmadmn9Ih6FUvztLtrBrkrbN3AOHHKevG@OrGHjohT5cXfqyvo7lRzxlFUV2jCZo4tpyByE2jMu0Dot@KkfGV@gZH5AIDOB@Q9T2xjJvKyhIoFptKbxB6qAgW5NIXco0zh83dO3mTpUZEBdoXyoIer4OLroF5EM6SjbxuGFjvRpg32hcD8HnxO5x7BaTIkMwZ4FIq0EyrYyfg0xvLyTiH64vusuAyWgVrllOXo3Y4Atm3o7vy@WRtPY9ma6e7G9oCRoO8MI@mTnCkTmFDU4pfYKaY4Hb86Q1UqSqGkay4FirWN/KsXOmBASoFuaTBD1/PnbfXQTJStNf5zdo6lP6SPoZ7hXtDf158v76JVWlDz5Idq1@4DrW7oV5t91a7bdLw). [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 36 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) I believe `O%5;4ṣ3œṡ€4Z%3’§§%"“ð<‘DŻ€ṫ€-j”:` should work for 32, but `œṡ` [seems to currently have a bug](https://chat.stackexchange.com/transcript/message/45712592#45712592). ``` O%5;4ṣ3i€4$œṖ"$Z%3’§§%"“ð<‘DŻ€ṫ€-j”: ``` A full program printing the result to STDOUT (as a monadic link it actually returns a mixed list of integers (albeit single digit ones) and characters (the `:`). Uses the `udlr` option for input. [Try it online!](https://tio.run/##y0rNyan8/99f1dTa5OHOxcaZj5rWmKgcnfxw5zQllShV40cNMw8tP7RcVelRw5zDG2weNcxwObobqObhztVAUjfrUcNcq////@dAQQqcTskpgsEUqgAA "Jelly – Try It Online")* Or see a [test-suite](https://tio.run/##y0rNyan8/99f1dTa5OHOxcaZj5rWmKgcnfxw5zQllShV40cNMw8tP7RcVelRw5zDG2weNcxwObobqObhztVAUjfrUcNcq/8Pd2853A7kRv7/X1palJKSwpVSVJoDZAFpIJEDBEWlXCm4QFEKAA "Jelly – Try It Online"). ### How? ``` O%5;4ṣ3i€4$œṖ"$Z%3’§§%"“ð<‘DŻ€ṫ€-j”: - Link: list of characters (in 'udlr') O - to ordinals %5 - modulo five ...maps u:2, d:0, l:3, r:4 ;4 - concatenate a 4 (to always end up with both hrs & mins - even when no r is ever pressed) ṣ3 - split at threes (the l presses) i€4$œṖ"$ - a replacement for œṡ€4 (split each at first occurrence of)... $ - \| last two links as a monad: $ - \| last two links as a monad: 4 - \| literal four i€ - \| for €ach get first index of (4) else yield 0 " - \| zip with: œṖ - \| partition at indices Z - transpose (to get a list of two lists of lists) %3 - modulo by three. To replace any 4(r) with 1 - ...while keeping any 0(d) as 0, or 2(u) as 2 ’ - decrement. All r are now 0, d are -1 and u are 1 § - sum each § - sum each. Now we have the total increase value as - ...integers for each of hrs and mins “ð<‘ - code-page indices list = [24,60] " - zip with: % - modulo D - to decimal lists Ż€ - prepend each with a zero (to cater for values less than ten) ṫ€- - tail each from index -1. Keeps rightmost two digits of each only) ”: - literal character ':' j - join - as full program implicit print (smashes the digits and characters together) ``` [Answer] # [APL (Dyalog Classic)](https://www.dyalog.com/), ~~97~~ 84 bytes ``` 5↑∊{¯3↑'0',':',⍨⍕⍵}¨24 60\|A⊣⍎¨'⎕IO←1' '⎕IO←0' 'A[1]+←1' 'A[1]-←1'['←→↑'⍳⍞,'←']⊣A←0 0 ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/p@m8KhtgkL1f9NHbRMfdXRVH1pvDGSpG6jrqFup6zzqXfGod@qj3q21h1YYmSiYGdQ4Pupa/Ki379AK9Ud9Uz39gZoN1RXgbAMg2zHaMFYbKg5i64LZ0epA6lHbJJDhj3o3P@qdpwMSUY8FmucI0qlg8L@WC2gOkJ2moK5OCvM/yO0gBDR9MgRxgalJYNEJcDm4KJQzAQmB1HLB9VMDgSwBAA "APL (Dyalog Classic) – Try It Online") Requires `⎕IO←1` [Answer] # [QBasic](https://archive.org/details/msdos_qbasic_megapack), 229 bytes A script that takes input as keystrokes and outputs to the console. Note: terminal `"` are included for syntax highlighting only, and do not contribute to the bytecount ``` z$=CHR$(0) DO x=0 y=0 SELECT CASE INKEY$ CASE z$+"K" r=0 CASE z$+"M" r=1 CASE z$+"H" x=1 y=1 CASE z$+"P" x=23 y=59 END SELECT IF r THEN m=(m+y)MOD 60ELSE h=(h+x)MOD 24 CLS ?RIGHT$("00000"+LTRIM$(STR$(h1000+m)),5) LOCATE 1,3 ?":" LOOP ``` ### Commented ``` z$=CHR$(0) '' Set var to null char DO '' x=0 '' Set Hours Shift to 0 y=0 '' Set Minutes Shift to 0 SELECT CASE INKEY$ '' Take keystroke input CASE z$+"K" '' If is Left Arrow r=0 '' Bool to modify right (minutes) CASE z$+"M" '' If is Right Arrow r=1 '' Bool to modify left (hours) CASE z$+"H" '' If is Up Arrow x=1 '' Set Hours Shift to 1 y=1 '' Set Minutes Shift to 1 CASE z$+"P" '' If is Down Arrow x=23 '' Set Hours Shift to 23 y=59 '' Set Minutes Shift to 23 END SELECT '' IF r THEN m=(m+y)MOD 60ELSE h=(h+x)MOD 24 '' Shift Minutes If `r=1` Else Shift Hours CLS '' Clear Screen ?RIGHT$("00000"+LTRIM$(STR$(h1000+m)),5) '' Use math to concat Hours and Minutes '' then Convert to String and prepend 0s '' to a length of 5 LOCATE 1,3 '' Cursor to the the third digit ?":" '' Overwrite that digit with a `:` LOOP '' Loop ``` [Answer] # Powershell, ~~109~~ 103 bytes -6 byte thanks [AdmBorkBork](https://codegolf.stackexchange.com/users/42963/admborkbork) ``` $t=0,0 $args\|%{$t[+$i]+=. @{l={$i=0};r={$i=1};u={1};d={119}}.$_} "{0:00}:{1:00}"-f($t[0]%24),($t[1]%60) ``` Test script: ``` $f = { $t=0,0 $args\|%{$t[+$i]+=. @{l={$i=0};r={$i=1};u={1};d={119}}.$_} "{0:00}:{1:00}"-f($t[0]%24),($t[1]%60) } @( ,('02:57',('u','u','r','d','d','d')) ,('00:00',('d','r','u','l','u','r','d')) ,('23:59',('d','r','r','d')) ,('00:01',('l','l','l','l','r','u')) ,('23:59',('d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d','r','d')) ) \| % { $e, $c = $_ $r = &$f @c "$($r-eq$e): $r" } ``` Output: ``` True: 02:57 True: 00:00 True: 23:59 True: 00:01 True: 23:59 ``` ## Explanation Basic idea is to use a `[hashtable]`, which `keys` are control commands and `values` are scriptblocks. The code execute the scriptblock for each command from arguments. [Answer] # [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~101 91 89~~ 86 bytes ``` {$/=[];$!=0;$_>2>($!=$_-3)\|\|($/[$!]+=$_-1)for .ords X%5;($0%24,$1%60).fmt("%02d",":")} ``` [Try it online!](https://tio.run/##dYvBCoJAFEX3fcU4vIkZMh2tXDTodwQiErxmNWI8m4Vk3z5ZEOiiu7rnXO79Rq4I3ci2lpUsPCEt68ZAVGoDbZVXcq7Q7g9qmiSkNUTN7sOZsj2xpCcc2EWcjAQt8mMMmSi0Smz3kFzoHHnMz1y9wnAdmZXcoyOuzOaHnhBxIZC8m93KrNDNIb/c/@V7C28 "Perl 6 – Try It Online") Anonymous code block that takes a string of `uldr` characters and returns in the given format [Answer] # perl -F// -E, 72 bytes ``` $x=H;/u/?$$x++:/d/?$$x--:($x=/l/?H:M)for@F;printf"%02d:%02d",$H%24,$M%60 ``` [Answer] ## Python, 120 bytes ``` o,i=[0,0],0 for s in list(input()):i=(i+(s=='r')-(s=='l')>=1);o[i]+=(s=='u')-(s=='d') print'%02d:%02d'%(o[0]%24,o[1]%60) ``` [Answer] # [Haskell](https://www.haskell.org/), 186 bytes ``` f(0,0)'<' f t i('^':r)=f(i#t$1)i r f t i('v':r)=f(i#t$ -1)i r f t i(x:r)=f t x r f(h,m)_ _=s h++':':s m ('<'#(h,m))n=(mod(24+n+h)24,m) (_#(h,m))n=(h,mod(60+n+m)60) s n=['0'\|n<10]++show n ``` [Try it online!](https://tio.run/##rY/LToNAFIb38xQn1GRmMmAGbGucAE@gK5e1EFLlEmFKGMQm6rZrrW/YBykOULEu3HnyJ@fy/WdOJo3U40Oetwl4cNfGhJucYhejGGrICA6wqKgXk2xSn9k0g@obNCcArFO06YEuN92IpGZBQwg9BSljWGChoEBEn5j0iEqPFOt74kyZZCl1pnqGSPgDddZ4zjUu6JxTpEB6C8zxq3RtvmRMpetnkG0RZVL/oYjKGyDlU31bV9cSziGhsDCCwG@axjDBaPzA1c1QDtnV4QeGaTR/hfYtEXqx0H770Wu3334O0ie5I2aXqG93PX0fPR3lgvORHofOhZhdod45qts9@m00vv8f@nXUemsPqziPEtVaq7L8Ag "Haskell – Try It Online") [Answer] # R, ~~368~~ 355 bytes ``` f=function(){C=as.character i=ifelse p=paste0 r=1:10 h=C(0:23);m=C(0:59) h[r]=p(0,h[r]) m[r]=p(0,m[r]) x=y=z=1 while(T){print(p(h[x],":",m[y])) v=1 n="[UDLRS]" while(!grepl(n,v))v=toupper(readline(n)) if(v=="L")z=1 else if(v=="R")z=0 if(v=="S")T=F if(v=="U")if(z)x=i(x==24,1,x+1)else y=i(y==60,1,y+1) if(v=="D")if(z)x=i(x==1,24,x-1)else y=i(y==1,60,y-1)}} ``` Definitely not the best approach, but works. Functionality: Run function, type each letter to (in/de)crease or move left/right, typing "s" ends the "game". The catch is that it will accept one and only one letter at a time. -13 bytes Consolidated some values into one row, overwrote T as F instead of using break, found several spaces to eliminate, and a string stored in a variable instead ``` f=function(){C=as.character # Abbreviate functions i=ifelse p=paste0 r=1:10 # Initialize and format values h=C(0:23);m=C(0:59) h[r]=p(0,h[r]) m[r]=p(0,m[r]) x=y=z=1 while(T){print(p(h[x],":",m[y])) # Begin while loop and print time v=1 # Initial value reset each iteration to retrieve a new direction n="[UDLRS]" # Used for verification and request while(!grepl(n,v))v=toupper(readline(n)) # Will only accept proper directions or stopping rule if(v=="L")z=1 else if(v=="R")z=0 # Evaluate for hour or minute if(v=="S")T=F # Stopping rule, overwrite True to False if(v=="U")if(z)x=i(x==24,1,x+1)else y=i(y==60,1,y+1) # Rules for Up if(v=="D")if(z)x=i(x==1,24,x-1)else y=i(y==1,60,y-1)}} # Rules for Down ``` I am also editing an alternate format to accept an R string and/or vector, will post next week. [Answer] # SmileBASIC, 123 bytes ``` @L B=BUTTON(2)D=(B==1)-(B==2)S=S+!S(B>7)-S(B==4)H=(H+D!S+24)MOD 24WAIT M=(M+DS+60)MOD 60?FORMAT$("%02D:%02D",H,M)GOTO@L ``` `BUTTON()` returns an integer where each bit represents a button ``` 1 = up 2 = down 4 = left 8 = right ... ``` `BUTTON(2)` returns only the buttons that were just pressed (not being held) `WAIT` is required because `BUTTON` only updates once per frame (1/60 of a second). Otherwise the same button press would be detected multiple times. This can definitely be shorter [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~38~~ ~~37~~ 32 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` 'l¡'rδ¡0ζć‚R€S„0uskOŽ9¦2ä%T‰J':ý ``` Uses `udlr` for the directions, but could also use `^v<>` for the same byte-count (the characters `↑↓←→` are not part of 05AB1E's codepage, so using those would increase the byte-count by a lot, since the encoding should be changed). [Try it online](https://tio.run/##AUYAuf9vc2FiaWX//ydswqEncs60wqEwzrbEh@KAmlLigqxT4oCeMHVza0/FvTnCpjLDpCVU4oCwSic6w73//2xsbHJ1cnVsZGRk) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn3lf/WcQwvVi85tObTQ4Ny2I@2PGmYFPWpaE/yoYZ5BaXG2/9G9loeWGR1eohryqGGDl7rV4b3/df6XlhalpKRwpRSV5gBZQBpI5ABBUSlXCi4AVALRlpNSBBbIKQUCrqKiHAjMAWEwgrKhfKChQGOhdA5QHwA). Explanation: ``` 'l¡ '# Split the (implicit) input on "l" # i.e. "lllrurulddd" → ["","","","ruru","ddd"] δ # Map each item to: 'r ¡ '# Split the item on "r" # → [[""],[""],[""],["","u","u"],["ddd"]] 0ζ # Zip/transpose; swapping rows/columns, with 0 as filler # → [["","","","","ddd"],[0,0,0,"u",0],[0,0,0,"u",0]] ć # Head extracted: pop and push the remainder and head-item to the stack # → [[0,0,0,"u",0],[0,0,0,"u",0]] and ["","","","","ddd"] ‚R # Pair the head and remainder back together, and reverse the pair # (so the remainder portion is basically wrapped in a list now) # → [["","","","","ddd"],[[0,0,0,"u",0],[0,0,0,"u",0]]] €S # Convert each item to a list of characters # (implicitly flattens and removes empty strings) # → [["d","d","d"],[0,0,0,"u",0,0,0,0,"u",0]] „0usk # Index each character into the string "0u" # (0 remains 0; "u" becomes 1; "d" becomes -1 since it's not in this string) # → [[-1,-1,-1],[0,0,0,1,0,0,0,0,1,0]] O # Then take the sum of each inner list # → [-3,2] Ž9¦ # Push compressed integer 2460 2ä # Split into two parts: [24,60] % # Modulo the two lists # → [21,2] T‰ # Divmod each with 10 # → [[2,1],[0,2]] J # Join each inner list together # → ["21","02"] ':ý '# Join the list with ":" delimiter # → "21:02" # (after which the result is output implicitly) ``` [See this 05AB1E tip of mine (section How to compress large integers?)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Ž9¦` is `2460`. ]
[Question] [ Your input will be an English sentence, phrase, or word. It will only contain `a-zA-Z' -,.!?`. Your task is to take the input, remove spaces, and then redistribute capitalization such that letters at indexes that were capitalized before (and only letters at indexes that were capitalized before) are capitalized. For example, if the input is `A Quick Brown Fox Jumped Over The Lazy Dog`, the (0-based) indexes of the capital letters are `0, 2, 8, 14, 18, 25, 30, 34, 39`. Next, remove spaces from the input: `AQuickBrownFoxJumpedOverTheLazyDog`. Next, lowercase all letters, but uppercase those at `0, 2, 8, 14, 18, 25, 30, 34, 39`: `AqUickbrOwnfoxJumpEdovertHelazYdog`, which is your output. # Input Your input will be an English sentence, phrase, or word. It can only contain lowercase letters, uppercase letters, hyphens, apostrophes, commas, periods, question marks, exclamation marks, and spaces. # Output The input with spaces removed, lowercase-d, with letters at the index of capital letters in the input uppercase-d. NOTE: Your program cannot crash (error such execution terminates) with an IndexOutOfRange or similar error. # Test Cases ``` Hi! Test! Hi!tEst! A Quick Brown Fox Jumped Over The Lazy Dog AqUickbrOwnfoxJumpEdovertHelazYdog testing TESTing TeStING testing testing TESTING testingtESTIngteStInGTEstingtestingtestiNG TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO TESTING.........success!eureKA???!!!maybe,don't,nooooo Enter PASSWORD --------- Enterpassword--------- A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz TEST teST ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~82~~ ~~79~~ ~~74~~ ~~72~~ ~~69~~ ~~67~~ 66 bytes ``` f(c){for(chars=c,p=c;c=s++;c&&putchar(c^(p++\|~c/2)&32))c&=95;} ``` [Try it online!](https://tio.run/##bZBNT8JgEITP8iuecqgtBUwwHkxDCEgVAUFoEePBpLwUqEhb@wGC4l/HYiDxwCSb3cxkZjcrClMhdruJItSviR8qYmaHuags8rmgLHRRzkWapgtZDpJ4LyniVckFmvb9Iy5KqnxZUlUhl6@v9O1uYbueoma@MmcTJdtwJSwniqWsqmfOUnOkZP/GVKvSS1wxpxb6K49b/5NmsgicMd2lE2LNHNr2Zk3dn54wx2mo602xDNP6644Z33fuOPL/9ZQ/kXBQisUix4oSIZwokjAGfaNVrVQqkiSxsNcjJ8/Y987jPJ3uHifyDC9Ozz7gsWqaw26/TuGIkw@wqTHiBkGdMQYOt0y4Y0qDGfe4NHmjxZw27zywoINHF59HAnp80CfEJMIiZkDCE0uGrHjmkxc2@1Xb3S8 "C (gcc) – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~14~~ 13 bytes ``` nŒlTɓḲFŒlŒuṛ¦ ``` [Try it online!](https://tio.run/##y0rNyan8/z/v6KSckJOTH@7Y5AZkHZ1U@nDn7EPL/v//76gQWJqZnK3gVJRfnqfgll@h4FWaW5CaouBfllqkEJKRquCTWFWp4JKfDgA "Jelly – Try It Online") ### How it works ``` nŒlTɓḲFŒlŒuṛ¦ Main link. Argument: s (string) Œl Convert s to lowercase. n Perform character-wise "not equal" comparison. T Get the indices of all truthy elements, i.e., the indices of all uppercase letters in s. Let's call the resulting array J. ɓ Begin a dyadic chain with left argument s and right argument J. ḲF Split s at spaces and flatten, removing the spaces. Œl Convert s to lowercase. ¦ Sparse application: Œu Convert s to uppercase. ṛ Take the resulting items of the uppercased string at all indices in J, the items of the lowercased string at all others. ``` [Answer] # [Python 2](https://docs.python.org/2/), 114 bytes ``` x=input() X=x.replace(' ','') print''.join([X[i].upper()if x[i].isupper()else X[i].lower()for i in range(len(X))]) ``` [Try it online!](https://tio.run/##LcqxCsIwEIDhvU9xdEkOJIN7JwdfIVA6FL3oSbg70hTj00cqjv/Hb5/6VDn33iYW26vHIU4tFLK83sg7cCfncLDCUp0LL2Xxc5x5CbsZFY@coB3J2x8obwS/I@v7gKQFGFigrPIgn0l8RFyw9/Gid4Kr5jR@AQ "Python 2 – Try It Online") # Equivalently: # [Python 2](https://docs.python.org/2/), 114 bytes ``` lambda x:''.join([[str.lower,str.upper][x[i].isupper()](x.replace(' ','')[i])for i in range(len(x)-x.count(' '))]) ``` [Try it online!](https://tio.run/##HYoxDsIwDEWvks22VDIwIjExcIiQIbQOBIU4clsRTh9atvfe//W7PKUcezzfeg7v@xRMOwHYl6SCzs2L2iwf1mGntVZW75pL3qb5b0gem1WuOYyMYGAAoG2nKGqSScVoKA/GzAUbHZodZS3LfiTy1KumzSLCRSY2V8lx6/0H "Python 2 – Try It Online") [Answer] # [Python 3](https://docs.python.org/3/), ~~78~~ ~~75~~ 72 bytes ``` s=input() for c in s:s=s[c>' '!=print(end=(c+c).title()[s<'@'or'['<s]):] ``` Thanks to @xnor for golfing off 6 bytes! [Try it online!](https://tio.run/##TZBLT8JAFIX3/RVfV9MqsjFxQaiIUt6C0ipG4gLLABWY1s4UwT@P9UHil9yc5NxHTm66N8tEnR/kTkaOEOKgvViluXFca55kRMQKXdGenkSXAmF7aRYr40g185zoNHLLJjZr6bgTXRVXIsnERFT1i1t5OfwOusVNTrhwD@3YJpTa2Fad@zyOVlxnyYeimezo5ptUzhhuZUa4lPSnn3saycIyxUKsFoR@EP6oDExn0OLo/@8XvvWn5XKZY@k8iqTWNv7DyO/Va7WabdtspvtXWWKWKGFKDIbfWL4yRYA/7upBMB6OGpwdKYJPueaVm@IvDWb4SJrMabGgzZIOMV3e6LGiz5pbNgxQDEm4I@Wed0ZkBGhCDA/kPLJlzAdP7Hjm8ws "Python 3 – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), ~~15~~ 14 bytes -1 byte thanks to [Emigna](https://codegolf.stackexchange.com/users/47066/emigna) ``` ðKuvy¹Nè.lil}? ``` [Try it online!](https://tio.run/##BcFJcgEBAADAr/QLFAdnZYtdRATlooxdhtiDKv9xdHXlYaM7nhwEiXEUve6V8Hh@PuqvWyzszw/XVBSlDWQEsoZyRvLGPkwUTBXNlMyVLVT8qgrVLNWtfPrTsPZlo2nr207L3o@DtqOOf10nPZc3 "05AB1E – Try It Online") ``` ðK # Remove spaces u # Convert to uppercase vy # For each character... ¹Nè # Get the character at the same index from the original input .lil} # If it was a lowercase letter change this one to lowercase ? # Print without a newline ``` [Answer] ## [Haskell](https://www.haskell.org/), ~~98~~ ~~95~~ ~~89~~ ~~88~~ 81 bytes Thanks to @name, @nimi, @Zgarb, and @Laikoni for helping shave off 14 bytes total ``` import Data.Char \s->zipWith(\p->last$toLower:[toUpper\|isUpper p])s$filter(>' ')s ``` Ungolfed: ``` import Data.Char \sentence -> zipWith (\oldChar newChar -> if isUpper oldChar then toUpper newChar else toLower newChar) sentence (filter (/= ' ') sentence) ``` [Answer] # Python 2, 100 bytes ``` s=input() print"".join([c.lower(),c.upper()][s[i].isupper()]for i,c in enumerate(s.replace(" ",""))) ``` [Answer] # [V](https://github.com/DJMcMayhem/V), 24 bytes ``` ÄVuÓó ejlDò/¥2lõ vuk~òGd ``` [Try it online!](https://tio.run/##BcFJEsFAGIDRfU7x3UCVGyDEPASh7JAYkjYE3UlZWLmBM7hAlAv4D9beM9bKM9Dyko8TxcqVovR7l5V8HaOThxReaG2FJVVW1FjjElInosEGjy1NdrTY0yamQ0IXRY8DfY4MODHkzIgUnwtjrky4MUUTYJiRMSdnwf0P "V – Try It Online") These kind of challenges are exactly what V was made for. :) Explanation: ``` Ä " Duplicate this line Vu " Convert it to lowercase Óó " Remove all spaces e " Move to the end of this line j " Move down a line (to the original) l " Move one char to the right D " And delete the end of this line ò " Recursively: / " Search for: õ " An uppercase character ¥2l " On line 2 " (This will break the loop when there are no uppercase characters left) vu " Convert it to lowercase k " Move up a line ~ " Convert this to uppercase also ò " Endwhile G " Move to the last line d " And delete it ``` [Answer] # JavaScript (ES6), ~~94~~ ~~91~~ ~~85~~ ~~84~~ 81 bytes ``` s=>s.replace(r=/./g,c=>1/c?"":c[`to${r<s[x]&s[x++]<{}?"Upp":"Low"}erCase`](),x=0) ``` * 6 bytes saved with assistance from ETHproductions & Arnauld. * 3 bytes saved thanks to l4m2 [Try it online!](https://tio.run/##XY9rT8JAEEW/@ytOG6MQsOg3YywNSn0iKC1iJCTWZcGqtHV3eajxt2M1YsSbzExyJnNn5jGaRlqoODNb093F0F1ot6odJbPnSMiCcitOZVQWbnWnIjzb3hO9O5Ouv6t93Zv3N/JUKvX33z88u5Nl9p7dSGf2h1SHkZZ3/UKxPHe3i4tMxYkpDAv2SWwRSm0su1hc@6U1riaxeOJApbOEo3TO2WScyQGtqVSED5JG9PZKPR2tjJncKE5GhH4QflcZmNPmMUv@t5/zldkf5jgOy9ATIaTWFn6n7Z/XPM@zLItx9HovywzSZNOUaba@tOLkJyY/8keXtSDottp1tpb692jEAfccIqgzwEdyxJBjRpzwwCkxZzxyzhMNnrlgTJOEFimXZFzxQhtFgCbE0GHCNVO6zLhhzi1vK/v4/j1Hi08) [Answer] # [Alice](https://github.com/m-ender/alice), 32 bytes ``` /..- ~l+u~mSloy \ia''-y.'Qa.+a@/ ``` [Try it online!](https://tio.run/##S8zJTE79/19fT09XoS5Hu7QuNzgnv5IrJjNRXV23Uk89MFFPO9FB////ktTiksy8dIUQ1@AQMJ0aXOLp564AE0eWB4oDAA "Alice – Try It Online") ## Explanation This is a standard template for programs that work entirely in ordinal mode. Unwrapped, the program is as follows: ``` i.' -l.uQm.lay.a-'~y+'~aS+o@ i take input as string . duplicate ' - remove spaces from copy l.u create all-lowercase and all-uppercase versions Q reverse stack, so original string is on top m truncate original string to length of spaces-removed string .lay convert everything except uppercase characters to \n .a-'~y convert everything except \n (i.e., convert uppercase characters) to ~ + superimpose with lowercase string \n becomes the corresponding lowercase character, and ~ remains as is '~aS convert ~ to \n + superimpose with uppercase string lowercase in existing string stays as is because it has a higher code point \n becomes corresponding uppercase character o output @ terminate ``` [Answer] # [Retina](https://github.com/m-ender/retina), ~~77~~ 71 bytes ``` .+ $&¶$& T`L `l_`.+$ +`((.))[A-Z].(¶(?<-2>.)) $1$3 .+¶ T`l `L_` .? ``` [Try it online!](https://tio.run/##TY7ZTsJQFEXf71esJhULhZuor8YGpUwiU@sQjaEMV6hAq7TI8GF8AD9Wi4HElZzsZJ3sZC9U7Af95MyoeIk0hZ7Z7/SMcL0G3qznSVMXpmcYMpvLvhULr@8yZ@x3hnVduLw5OKFf6FcIae53Ii3N8Bo9D2klSdXXcFUUa6JIZ@kPp9wuwlVAOVxTX86/1IjWj1rgThSN/nZDKRyLOC34wRjXdty/VE5ca1Y4@f//1ItjSik5XbQcDlUUadiPXfu@aFmWpmnM@5uByjMKg/M4T7N1QNhBnA440i46znOrW6JwIh3e55YBdwwpMcJGUeaDCmOqTKjhU@eTe6Y0mPHAnCYBLULafNHhmy4LHCJcYh5Z8sQPz6x4Yc0r218 "Retina – Try It Online") Link includes test suite. Explanation: The first stage duplicates the line while the second stage lowercases the duplicate and deletes its spaces. The third stage then loops through each uppercase letter from right to left and attempts to place a space before the corresponding character on the second line. The first line is deleted and the spaces are used to uppercase the relevant characters of the result. Edit: Saved 6 bytes thanks to @Kobi. [Answer] # Java 8, ~~184~~ ~~177~~ 161 bytes ``` s->{String r="";for(int i=0,j=i,t,u;i<s.length;){t=s[i++];if(t>32){u=s[j++];r+=(char)(t<65\|t>90&t<97\|t>122?t:u>64&u<91?t&~32:u>96&u<123\|u<33?t\|32:t);}}return r;} ``` Can definitely be golfed some more.. - 16 bytes thanks to @OlivierGrégoire* by taking the input as `char[]` instead of `String`. Explanation: [Try it here.](https://tio.run/##lVJNb9pAEL3nVzxzoLYAK0BLRY2xSEK@AwkmTVXEwZgFlg@b7s6SEHD/Ol0ISD20B0Y72p03OzNvRjMOFkEunrNo3J9swmkgJR4CHq1OAB4RE4MgZGhsTcAnwaMhQjMcBaLTlZaj4USrPpIC4iEaiOBiI3PV1f63cFMpZxALU6cDd0@zY5dnKascXpH2lEVDGjnWilzZ4ZlM1@EDk6rFgrVSGhlvEZFxdwUtkyqlL2uqlk/TVCl/1a98oeDRN1UtfU6rSjnvUfp3saDtcknb@UJxrSrFokdrDZLlJIlgpEQE4SQb54P2XPWmmvae/SLmfcx0@@YH@U4XgbXvfSmJzexYkT3XLppGZmSHZuqaG2gzSUbKpvhc06wJESxNy9oN5/9xNTwpHk5wJuLXCJfxG27VbM76aC6YQHvEcB@8L3ERD49MTJrMdu7tut/e3cynm8YVDvjffo0fmX0fZds2DipVGDIpDdSfW/W7mud5hmHoKS57LIt@HH2iLBrNrRxZq77dP@zlseb7L83WBXIHOXrgAc7QwzlCXKCPOhguMcAVhrjGCDfguMUYd5jgHlM8YLbb5iZiPGKOJ/xCCwI@JNogPEPhOxZ4wSt@4A0/8f5PRslJsvkD) ``` s->{ // Method with char-array parameter and String return-type String r=""; // Result-String for(int i=0,j=i,t,u; // Some temp integers and indices i<s.length;){ // Loop over the String t=s[i++]; // Take the next character and save it in `t` (as integer) // and raise index `i` by 1 if(t>32){ // If `t` is not a space: u=s[j++]; // Take `u` and raise index `j` by 1 r+= // Append the result-String with: (char) // Integer to char conversion of: (t<65\|t>90&t<97\|t>122? // If `t` is not a letter: t // Simply use `t` as is :u>64&u<91? // Else if `u` is uppercase: t&~32 // Take `t` as uppercase :u>96&u<123\|u<33? // Else if `u` is lowercase or a space: t\|32 // Take `t` as lowercase : // Else: t); // Take `t` as is } } // End of loop return r; // Return result-String } // End of method ``` [Answer] # Perl, ~~95~~ 94 + 1 = 95 bytes +1 byte penalty for -n Save one byte by replace from `s/\s//g` to `s/ //g` ``` $s=$_;s/ //g;$_=lc($_);while(/(.)/gs){$p=$&;$p=uc($p)if(substr($s,$-[0],1)=~/[A-Z]/);print$p;} ``` [Try it online!](https://tio.run/##Dcm9CsIwFEDhV7niRRJojQ5OIUNFHEQQwclSitbYBmt7SRrrD/rqscv5hkPa1oswHtEgxE1ApzCXToAQpcRc1QXDnMu@MrVmgk25KB3/ICmcyKF@2MTNlTl/dp1l6CKM01kWzbn6iTSJj5ngkqxpOiT5DSGBvTfFDZa27RtYt0/Y@DvpC@we2sKh0rA9vV@wass/ "Perl 5 – Try It Online") Explanation: 1. Make copy of input string. 2. Remove all spaceses and transform string to lower case. 3. Then start loop over each letter. Test letter in same position in saved string for upper case. If it upper - make current letter captitalized. Print letter. Note that perl need to be run with "-n" command line switch [Answer] # [Python 3](https://docs.python.org/3/), 117 114 98 bytes ``` s=input() i,y=0,s.replace(' ','').lower() for c in y:print(end=[c,c.upper()]['@'<s[i]<'[']);i+=1 ``` [Try It Online!](https://tio.run/##FcqxCsIwEADQ3a@47doaiuKmBlTEQQQR3EKHkp42WJMjbazx56O@@XEcWmcXKfXSWA5Dlk@MKKKciaIvPXFXa8oQUCDmZedG8r9xcx40GAtxyd7YISPbSKWFLgPzf1QKN7julanWqLDKV2Yq5ylt4RKMfsDOu9HCwb3hGJ5MDZxf5OHaEpzqT4S9u38B) Edit: 3 bytes saved by UndoneStudios. Edit: 14 bytes saved by Unrelated String. This is pretty much my first code golf, so it's likely to be bad, minus help from comments below! P.S. Yes, it's dumb that defining and incrementing `i` saves bytes over range(len(y)). Oh well. --- # Python 3, 85 bytes ``` lambda s:''.join([c,c.upper()]['@'<b<'[']for b,c in zip(s,s.replace(' ','').lower())) ``` [Try It Online!](https://tio.run/##FctBC4IwFADgv/Jub4OxS5cIg4rwEEEE3czDnDNXuveYmumft/ruH099TWG15rhU2/vSmLYoDXQbRP0kH0RmldUDs4tC5hnuMCkSzDCvKEKhLPgAs2fRqU5Hx42xTiCgQpS6ofG/pFw4@tCLSuAeroO3LzhEGgOk9IHT0LIr4fJ2EW61g7OZJzjSA3/tCw) This solution is entirely due to att; I'm keeping it separate because the strategy seems to me to have changed enough. [Answer] # [Java (JDK)](http://jdk.java.net/), 84 bytes ``` s->{int j=0,c;for(var k:s)if((c=k&95)>0)System.out.printf("%c",c^(s[j++]\|~c/2)&32);} ``` [Try it online!](https://tio.run/##bVJdb9owFH3vrziJtC5RQ1Z12sOaAaJAvwstSddpjEnGSSAJsVnspKUd@@vMgVCqaVe2LJ3rc33uPY5JQWqxn6zm@XgWUdAZEQI3JGJ42QOEJFKhsbpl5zKa2WHOqIw4s9uciTwNsi90SrLhqIEQdaxErfESMYm4fmhRJ@SZUZAMybEwo9AwaD3Z//zJbBya7kLIILV5Lu15pgihob@jukV/GmIYHxyMfv@hH47M/Y9HprNcQYWjxKhVqaxkFTzykSqthitVlclwBGKWsoFXQAZCCiVtAwP6eaTBU6CmW1uohbs8oglOMv7IcMqfcJmn88BHvwgyeNMA1@R5gQ6f7DhlXfUCvK7rrc/AlRe9M2zxt3mF74gVYNs2tlvklAZCaOjeD7pXrWazqWmaamwxDiz4nL2XFnr9MnZlukwqbVXctlz3oT/ooLaNt80RnGCMNig68NFFgFPl1hkmOMcUF4hwiRhXSHCNGW6QogeGPjhuMccdfmGADC4EPEjcI8dXFHjAI77hCd/xrK/fWjrrozR9M/31DI43DpivBvxr/YwZ5Q3TqfKhTdQ05nKN2pK31f9qZRlZGKbp/Ies/2B6RV7ulXu5@gs "Java (JDK) – Try It Online") # Credits : * Dennis for the bit twiddling as it's a good way to shorten the answer * Fhuvi for trimming 12 bytes. [Answer] # [MATL](https://github.com/lmendo/MATL), 18 bytes ``` kXz"@GX@)tk<?Xk]&h ``` Same approach as [Riley's 05AB1E answer](https://codegolf.stackexchange.com/a/128938/36398). [Try it online!](https://tio.run/##y00syfn/PzuiSsnBPcJBsyTbxj4iO1Yt4/9/dUeFwNLM5GwFp6L88jwFt/wKBa/S3ILUFAX/stQihZCMVAWfxKpKBZf8dHUA "MATL – Try It Online") [Answer] # [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 108 101 bytes ``` using System.Linq;s=>s.Replace(" ","").Select((c,i)=>s[i]>64&s[i]<91?char.ToUpper(c):char.ToLower(c)) ``` [Try it online!](https://tio.run/##pVBNSwMxEL3vrxj2IAm0AUEEbbtS@0Wl2tpd6UE8xHTaBrfJmmRbq/jb12y7BREv4rsM8x5v5s0IWxfaYJFbqZYQ76zDNRtJ9doIApFya2ESfATgYR13UsBGyznccqkI3dMHsURl7udKNK0zfl6tojo6TVE4qZVlA1RopGDDnsrXaPhzik2x4iaKYAEtKGwrsmyKWcoFkhDCWhhSFmPpJ0TUJPX6o3yKzs9Oytq8OL0q7SzRD1mGhgh6WfUjvd33tPC3/AjZ8VF0imxmpEN/LhKFWzikJgsStuE@l@IFro3eKujrN7jJ1xnOYbxBA8kKYcTfd9DVS58u0W1j@I5QSht/XeTQuvLzSS9O9hVjN7wbwJH/rnv@n9t6yvn4FSbtOJ6Np12oH/Hb9M/gs/gC "C# (.NET Core) – Try It Online") * 7 bytes saved after realizing that the `char` class has static `ToUpper()` and `ToLower()` methods. [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal), 33 bytes ``` Ａ⁰χＦＬθ¿⁼§θι Ａ⁺¹χχ¿№α§θ⁻ιχ↥§θι↧§θι ``` [Try it online!](https://tio.run/##S85ILErOT8z5/37PQkeFwNLM5GwFp6L88jwFt/wKBa/S3ILUFAX/stQihZCMVAWfxKpKBZf89HM7QOofNW443/5@z7L3e9ac23Fo/6PGPYeWn9txbqcCWG7XoZ3n28@3A8Vbpp3bCJJ51Lj7HFDsUdtSiLpHbcshjP//AQ "Charcoal – Try It Online") As I still don't know how to pass a string with whitespaces as a single input parameter into Charcoal code, I just assign in the header the test string to the Charcoal variable that represents what would be the first input (`θ`): ``` ＡA Quick Brown Fox Jumped Over The Lazy Dogθ ``` So the code has the same number of bytes as if the string were passed as first input. You can see [here the verbose version](https://tio.run/##bY3BisIwFEX3fsXFjS8QQddd1VFBqcwI4weENLbBmrRJY3V@PraiyIBve885T5bCSSuqmHqvC0PjFPug5QkLZzuDtb1iG861yvF9UQ6/pUIm/m5Y2mLM0bDkJc64ZMnoaB0oU6ZoS2oYGwH6CFo1QVSe0nZjcnWlhmvGJ5g8duAZSPOc5n2EYwgNw6B@2WBaEvzt7rQJnnRP9ocHCPw43WOHulZOCq/@vWLP3IvKbPeZijFOL3Hqqzs) of the code. [Answer] # PHP, 181 bytes I try get the minor numbers of bytes,this is my code: ``` <?php $s=readline(); preg_match_all('/[A-Z]/',$s,$m,PREG_OFFSET_CAPTURE); $s=strtolower(str_replace(' ','',$s)); while($d=each($m[0]))$s[$d[1][1]]=strtoupper($s[$d[1][1]]); echo $s; ``` [Try it online!](https://tio.run/##TYzLasMwFET3@Yq7EEgGh6TrNBQ3sQOlkEfdTY0RQr5EJnJ0kew67c@7KtkEZjEMcw4ZmqbnFzI0Y2HtUTW2vaJIVjPyeJad6rWRylrBF1U2/6oXPGUhZV16OOU7uS@Kj7yUm@xQfp7yCEVH6H3vrBvRi1ilR7JKo@DAU/4PJ/E2mtaiYM0alTaCddWyThIWKtZUT3VMfbcMRNHyuEcWtXHAwmqaMjgOrb7Aq3fjFQp3g7ehI2xg/40eSoPwrn5/YOvOfw) [Answer] # Common Lisp, 104 bytes ``` (defun f(s)(map'string(lambda(x y)(if(upper-case-p x)(char-upcase y)(char-downcase y)))s(remove #\ s))) ``` [Try it online!](https://tio.run/##LYxBCsIwFESvMtSFP4seQhEXIojg0k1MftqgaT9JU1svX1NxOY95z7x8kmUhyy53cJQUBS3bNETfNfTS4WE1TZgVeUdZhGNtdOJaMCkyrY51lhWsj9@0/bv7A6USRQ79yNjcgVTAQlLCA8ih2uGavXliH4uCYz/hlIOwxWXkiFvLOOvPjEPfVEX8Ag) Unusually short for the wordy Common Lisp! Straightforward code: ``` (defun f (s) ; receive the string as parameter (map 'string ; map the following function of two arguments (lambda (x y) ; x from the original string, y from the string with removed spaces (if (upper-case-p x) ; if x is uppercase (char-upcase y) ; get y uppercase (char-downcase y))) ; else get y lowercase s (remove #\ s))) ``` [Answer] # Google Sheets, 213 bytes ``` =ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Z]"),MID(UPPER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1),MID(LOWER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1)))) ``` Input is in cell `A1` and the formula breaks down like this: * `ArrayFormula()` lets us evaluate each term of `ROW()` independently * `JOIN()` concatenates all those independent results into a single string * `IF(REGEXMATCH(),UPPER(),LOWER()` is what makes it alternate using upper or lower case depending on what the case was at that position in the input * `ROW(OFFSET())` returns an array of values `1` to `A1.length` that can be fed into the `MID()` function so we can evaluate each character in turn Results of test cases: (It's easier to read if you click though to the larger version.) [![TestCases](https://i.stack.imgur.com/zeGyF.png)](https://i.stack.imgur.com/zeGyF.png) [Answer] # [Ruby](https://www.ruby-lang.org/), 80 bytes ``` ->a{n=a.downcase.delete' ' n.size.times{\|i\|(?A..?Z)===a[i]&&n[i]=n[i].upcase} n} ``` [Try it online!](https://tio.run/##TYzLDoIwFET3fMVdUV3YP6gE4yMaozGwkrCocIONUghtVV7fXsGExM1MciZnKnOrrYPMLpa8lYzTtHjLhCukKT5RIwHiSKpEg1SLHFXbiW7m@ZR61zljjEcidl05JBuDmnJ0e0f2tjRaAUbEh4sRyQNW1fAM2@IDB5OXmML5hRWEd4Qjb2pYFxmJnUnSqLSQGYSbIPw1Bnp/2sHE//eBk9h@AQ "Ruby – Try It Online") [Answer] # Perl, 92 bytes ``` $p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;s/\s//g;for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};print; ``` Explanation: ``` $p[$i++]=$-[0]while s/[A-Z]/lc($&)/e; #get locations of caps into an array at the same time converting letters to lowercase s/\s//g; #delete all spaces for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]}; #convert lowercase letters to uppercase where uppercase letters were present print; # print (of course) :) ``` [Answer] # [Perl 5](https://www.perl.org/), 40 bytes 37 bytes of code + `-F` flag. (note that on old versions of Perl, you might need to add `-an` flags) ``` print$F[$i++]=~/[A-Z]/?uc:lc for/\S/g ``` [Try it online!](https://tio.run/##K0gtyjH9r6xYAKQVdN3@FxRl5pWouEWrZGprx9rW6Uc76kbF6tuXJlvlJCuk5RfpxwTrp///76gQWJqZnK3gVJRfnqfgll@h4FWaW5CaouBfllqkEJKRquCTWFWp4JKfDgA "Perl 5 – Try It Online") Explanations: Thanks to `-F`, `@F` contains a list of every characters of the input. `for/\S/g` iterates over every non-space character of the input. We use `$i` to count at which iteration we are. If `$F[$i++]` is an uppercase character (`/[A-Z]/`), then we print the uppercase current character (`uc`), otherwise, we print it lowercase (`lc`). Note that `uc` and `lc` return their argument unchanged if it isn't a letter. --- Previous version (less golfed: 47 bytes): ``` s/ //g;s%.%$_=$&;$F[$i++]=~/[A-Z]/?uc:lc%ge ``` [Try it online!](https://tio.run/##K0gtyjH9r6xYAKQVdAvc/hfrK@jrp1sXq@qpqsTbqqhZq7hFq2Rqa8fa1ulHO@pGxerblyZb5SSrpqf@/@@oEFiamZyt4FSUX56n4JZfoeBVmluQmqLgX5ZapBCSkargk1hVqeCSnw4A "Perl 5 – Try It Online") [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal), 18 bytes ``` ⪫Ｅ⪫⪪θ ω⎇№α§θκ↥ι↧ιω ``` [Try it online!](https://tio.run/##PYxNCsIwEEb3nmLoKoF6AldVESwVFesBhnSwoTUTx/56@RgVXHzwHjw@U6MYxjaEk1jXqZytUwf0P7j41nbqkUICiU5hjCtJHMqsNtzHHFPIur2raPpUjY7B1XsSg09SNlrB49/090KvQsjg3FvTwFp4dLDjCfL@7qmC40ACZU1Q4GuGLd8WYTm0bw "Charcoal – Try It Online") Link is to verbose version of code. Explanation: ``` θ Input string ⪪ Split on spaces ⪫ ω Join together Ｅ Loop over each character §θκ Get character from original string №α Search uppercase letters ⎇ If true (nonzero) ↥ι Uppercase the current character ↧ι Else lowercase the current character ⪫ ω Join together Implicitly print ``` The recent addition of StringMap shaves off a couple of bytes: ``` ⭆⪫⪪θ ω⎇№α§θκ↥ι↧ι ``` `⭆` is roughly equivalent to `⪫Ｅ`...`ω`. [Answer] # [GNU sed](https://www.gnu.org/software/sed/), 67 + 1 = 68 bytes +1 byte for `-r` flag. ``` :A s/$/;/ : s/([A-Z]);(.?)/;\l\1\u\2/ t s/(\S);/;\1/ t s/ ;// / /bA ``` [Try it online!](https://tio.run/##TY9Za8JQFITf76/4AoUqqBf7aB4k1rjXLbEWmz643GqqJjaL249vGq1CBw5zzgwDc0K1SJKSIUL5IHUpSumSeTfyk4@snimUs1J3Nk7RiZ0nKaKL51hZPRWLfye6lEIiZ0aSNFwNW4WRJgwGsTtfUwn8g0fNP9KKtzu1oLdXAfZK0ZmeT1T9pYjSgOstsU3LvrKyoma3zl3/76e6uHGhUOA@YTyfqzDUMEdDs22Uy2VN09hOTzOVY@F7j1GObu8CYXpRWuCGvmFZ496wSv6OtPiUCjOemVNlgYmixid1ljRY0cSlxRdt1nTY8MKWLh49fPrsGPDNkACLEJuIETGv7Blz4I0jE86C6y8//i5yfS9M8sEv "sed 4.2.2 – Try It Online") ## Explanation The algorithm is pretty simple: 1. Insert a cursor (`;`) at the end of the line: ``` :A s/$/;/ : ``` 2. If the character before the cursor is an uppercase letter, lowercase it (`\l`) and uppercase the character after the cursor (`\u`), moving the cursor to the left, and branch back to `:` ``` s/([A-Z]);(.?)/;\l\1\u\2/ t ``` 3. Otherwise, if the character before the cursor is not a space, move the cursor to the left and branch back to `;`: ``` s/(\S);/;\1/ t ``` 4. Otherwise, if the cursor is preceded by a space, delete both: ``` s/ ;// ``` 5. Finally, if there are any spaces left, branch back to `:A`: ``` / /bA ``` [Answer] # [Rust](https://www.rust-lang.org/), 143 bytes ``` \|s\|str::to_lowercase(s).replace(' ',"").chars().zip(s.chars()).for_each(\|(c,d)\|print!("{}",if d.is_uppercase(){c.to_ascii_uppercase()}else{c})) ``` [Try it online!](https://tio.run/##fVPbTuMwEH3PV5z2ARKpBO1rVl1UINyhQNuF5QWliUMNqR1sp/d@OztOGygIMVI8zsyZM5dMVKHNW170kQoMIy5cDzt/QOfcAUnGDEYBOd0tbZSHJrC7CzPNGSIhpIkMlwJSZFMIFsdM60hNwQXMgEFmCW6JHyOmtMUVmiXoT0FBvirE20IviDUIjHzM5JipONLM1Z6vWJ5FMXO3sd2o1z0/HkRKu54/47mrqzfPT6V6ZFE8cBdu3Ei8Ra64MDW3Pl/WGzxF4nP9WOT5mtebxz4linTM@aZ5yTLN5vHS895@v/esTUJNNK0OAi6DoDS43gdiWBjqM6eziY6hzE9BINj4K6RfpClT32PGA56xEtl@cX/5frPMVmg@Y0Fw2br3VgVwQQOJkseMC@ZufZBW38gKtVsWY1tmw9xM3U1viVjXuor140wS27oQK8v3m52HJVwjqe4hzf5nYuJjkfqB73NM9aVObWxgLfNlOMlZbFgS0L1dmLWj3sBWmYH0uu3fn6hG7sr/xVxmyATlqJPnm6re57BR99JZvp3wGrpMm5pDNxPai9PCTcHjF@wrORY4khOcFcOcdrlNm40urfpFNJviUD45rdceIfuqPRapnFhYmEhCmROWRbN/CUEcQ/S0C@iGnW6pWcecXh2jsm/6yV7hjX0lZdHiuBuujOxDEdRZx/i@j@rRRflj1hD2bsPz1t7eXq1Wo5992mcNJFJs02yv2lY2oldShbJCsSpyFbiKE9KK44TC0CDWct3qdO7at4fYqWTlzyOtx1IlH2YabIR99HGAGIdIEILhCCmO8YQTDHAKjjM84xwvuECGSwxxBYE2JK6R4wavuIVCBxpdGPRQ4C9GuMMY95jgATOnFfX7B3GShCxNj58Gg1P@/Hz@kmWXQyHaMs9vXpXqaGN6xWh0N55MHmZ2XewkaPB0/Ac "Rust – Try It Online") Ungolfed: ``` \|input: &str\| input.to_lowercase() // create lowercase string .replace(' ', "") // remove all spaces .chars() // iterate over characters .zip(input.chars()) // zip with input character iterator .for_each(\|(c, input_c)\| // for each character in both strings: print!("{}", // print the following: if input_c.is_uppercase() { // if the input character is uppercase c.to_ascii_uppercase() // `c` in uppercase } else { c } // else `c` ) ) ``` [Answer] # [Go](https://go.dev), 184 bytes ``` import(."strings";u"unicode") func f(s string)string{S:=[]rune(ReplaceAll(ToLower(s)," ","")) for i:=range s{if i<len(S)&&u.IsUpper(rune(s[i])){S[i]=u.ToUpper(S[i])}} return string(S)} ``` [Attempt This Online!](https://ato.pxeger.com/run?1=VVPbbptAEH3oG19xjJQUJEJfK6c0cmLiOBc7Mbhpc1GFYbGJ8S6GxXaM_CV9iSr1H9pPab-mA9hKOxI6y5k5s8Pu4dv3sXj5lXj-1BszzLyIK9EsEak01XAm1R-5DA_e__5Zc5qpZjKN-DhTD3M155EvAqbqSphzH6GWoc7qNRRO07p_THPOtAFLYs9nrTjWXHEplizVMt1QoRqqqpNepIiaVupxmiErohDRh5hxzdH393Ozmw2ThBRVp-w-etT1wiGwctMVdap81TcbJWUyT_l2DJJv6vn_vHknnxMGt8zkvkQR8cQAWyXb0o1Sf0P5_ZqOQlEky2SGpoX7R7dQCvUsasAlrkEj01ra5XJjUKaFmzzypzhOxZLjVKxwns8SFqC_YCncCcOlt35GW4xJ2poPqXaU9pc8FKuy0A4E1ckzFnvrLwEVVU3L7WkuuLbjVsgc2e11sOP_zRNPnbeMLAmCsp53XLsm2StQcbXDVmmaJnZPlvs-y7IG7OHAvmgdHR01Gg06k-cRMxAI_lYa6PXLoP1e9XXsxCxP2U5bS2slF2XUe9tc0tFs47rlOLf9QRsHu6DuVUXiZdlSpMFrYnvgHo4xwgl8tBHABsMpQnQwxhkm6CLCOZ5wgSkuEeMKM_TA0YfANRLcYI4BUjjIyBESQ-T4hAVuscRnrHCHdXlT3mh04geBzcKwM55MutHT08U0jq9mnPdFktzM09TJpBzmi8XtcrW6W9fTobqT6kIIiCJvXZPHZMw11bIsOG5r4IJWam38r4YsfVabv7ZdoXh-RYaaNMmqukK_hJg2LWmSZy2LsocNMUVRNQ41dW_-wGF9RIlahTr25ANXDVQNDJCkXJPcoE76hsb6byrYvTa2UynK9r95eanxLw) [Answer] # [Noulith](https://github.com/betaveros/noulith), 88 bytes ``` \s->(for(p<<-s.lower filter (!=' '))yield if(s[p[0]].is_upper)p[1].upper else p[1])join"" ``` [Try it online!](https://betaveros.github.io/noulith/#Zjo9Cgpccy0+KGZvcihwPDwtcy5sb3dlciBmaWx0ZXIgKCE9JyAnKSkgeWllbGQgaWYoc1twWzBdXS5pc191cHBlcilwWzFdLnVwcGVyIGVsc2UgcFsxXSlqb2luIiIKCjsKCnN0cnVjdCBUIChpbnAsd2FudCk7Cgp0cyA6PSBbClQoIkhpISBUZXN0ISIsIkhpIXRFc3QhIiksClQoIkEgUXVpY2sgQnJvd24gRm94IEp1bXBlZCBPdmVyIFRoZSBMYXp5IERvZyIsIkFxVWlja2JyT3duZm94SnVtcEVkb3ZlcnRIZWxhellkb2ciKSwKVCgidGVzdGluZyBURVNUaW5nIFRlU3RJTkcgdGVzdGluZyB0ZXN0aW5nIFRFU1RJTkciLCJ0ZXN0aW5ndEVTVEluZ3RlU3RJbkdURXN0aW5ndGVzdGluZ3Rlc3RpTkciKSwKVCgiVEVTVElORy4uLiAuLi4gLi4uIHN1Y2Nlc3MhIEVVUkVLQT8/PyEhISBtYXliZSwgZG9uJ3QsIE5PT09PTyIsIlRFU1RJTkcuLi4uLi4uLi5zdWNjZXNzIWV1cmVLQT8/PyEhIW1heWJlLGRvbid0LG5vb29vbyIpLApUKCJFbnRlciAgICAgICAgUEFTU1dPUkQgLS0tLS0tLS0tIiwiRW50ZXJwYXNzd29yZC0tLS0tLS0tLSIpLApUKCJBIGEgQiBiIEMgYyBEIGQgRSBlIEYgZiBHIGcgSCBoIEkgaSBKIGogSyBrIEwgbCBNIG0gTiBuIE8gbyBQIHAgUSBxIFIgciBTIHMgVCB0IFUgdSBWIHYgVyB3IFggeCBaIHoiLCJBYWJiQ2NkZEVlZmZHZ2hoSWlqaktrbGxNbW5uT29wcFFxcnJTc3R0VXV2dld3eHhaeiIpLApUKCIgIFRFU1QiLCJ0ZVNUIiksCl07Cgpmb3IgKHQgPC0gdHMpICgKYSA6PSBmICh0LmlucCk7CmlmIChhIT10LndhbnQpIHByaW50KHQuaW5wLCJcbiIsYSwiXG4iLHQud2FudCwiXG4iLHQud2FudD09YSwiXG4iKTsKKTs=) [Answer] # C, 103 bytes ``` i,j,c;f(chars){for(i=j=0;c=tolower(s[j++]);)c-32&&putchar(c-32(s[i]>64&&s[i]<91&&c>96&&c<123))&&++i;} ``` [Try it online!](https://tio.run/##bZBZT8JAFIXf/RVfeaitLHELialIUOqKoLQu0fiAwwCD0GI7FZf423FqJPGBk9xl7rn3zMwV5aEQi4UqjUvCGzhi1Es2UvdrECeOqo1rm56o6XgSz2XipI/jYvHJ9VxR3tm27Vmm824nP20YUj0dVHdtO0/297ZsWxzsVY3f39recV3bLhaV971QkWbaU5Hjrn2tYTBwCqfKIpSptgquZ0RTp2CSJdngOlPihcMknkccx@@cZ9OZ7NN5kwnhSNLqfX7QjIerprWRVdGQ0A/C3ygDfdY@YVn/z5v6Kok/qlKpsLQ0E0KmqYV/0/UvGvV63bIs862PZ1miH0frukS7k2OVoB9p8/I/XDWC4K7TbVJeYvUSehzyzBGCJn18JMcMOGHIKSPOUJwz5oIXWky4ZEqbiA4xV8y45pUuCQEpIZobMm55444597zzwGd@2/fiBw) ]
[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/12340/edit). Closed 9 years ago. [Improve this question](/posts/12340/edit) Sometimes people get frustrated on the StackExchange network (specifically SO). ![stackoverflow logo modified](https://i.stack.imgur.com/VWPZg.gif) Your task is to create a bookmarklet that causes StackOverflow to explode/implode/destroy in some fashion. This will provide a nicer way of dispersing our frustrations. The Rules: * it must be in the form of a bookmarklet * must work in Chrome and Firefox (latest stable) * jQuery is on the site, so you can use it * no creating a script tag that pulls explosionThisPage.js or similar Scoring is the number of characters that need to be copied and pasted, except: * -1 if you include an explanation * -5 for each upvote * -10 if you don't use jQuery * -10 if it makes an explosion sound * +9e72 if it actually does harm to the site (F5 should repair the damage) If the gif's distracting, remove it. [Answer] Here's my entry, which I'll call the drunkenator: ``` javascript:void(setInterval(function(){c='1234567890poiuytrewqasdfghjklmnbvcxzZXCVBNMLKJHGFDSAQWERTYUIOP=)(/&%25$%23"!1';$(':not(iframe,script,style)').contents().each(function(){if(this.nodeType==3&&/\S/.test(this.nodeValue)){a=this.nodeValue.split('');x=0;for(i=0;i<a.length;i++){r=Math.random()9999;if(r<10){x=1;j=c.indexOf(a[i]);a[i]=(r<4%3F(t=a[i-1],a[i-1]=a[i],t):r<5%3F'':r<6%3Fa[i]+a[i]:j<0%3Fa[i]:c.charAt(j+(r<8%3F1:-1)))}}if(x)this.nodeValue=a.join('')}})},100)) ``` At 474 chars, it's probably not going to win any golf prizes, but I'm hoping to make up for it in upvotes. :) Here's the same code de-obfuscated: ``` setInterval(function () { var c = '1234567890poiuytrewqasdfghjklmnbvcxzZXCVBNMLKJHGFDSAQWERTYUIOP=)(/&%$#"!1'; $(':not(iframe,script,style)').contents().each(function () { if (this.nodeType==3 && /\S/.test(this.nodeValue)) { var a = this.nodeValue.split(''); var x = 0; for (i = 0; i < a.length; i++) { r = Math.random() 9999; if (r < 10) { x = 1; j = c.indexOf(a[i]); a[i] = ( r < 4 ? (t = a[i-1], a[i-1] = a[i], t) : r < 5 ? '' : r < 6 ? a[i] + a[i] : j < 0 ? a[i] : c.charAt(j + (r < 8 ? 1 : -1)) ); } } if (x) this.nodeValue = a.join(''); } }); }, 100); ``` What it does is randomly mutate the text on the page, swapping adjacent characters, deleting or duplicating characters or replacing them with ones adjacent to them on the keyboard. The effect is kind of subtle at first, but leave it running for a while, and the page content will inevitably decay into a mess of drunken typing: ![Go home, SO, you're drunk!](https://i.stack.imgur.com/SUdJ1.png) Ps. The code isn't in any way SO-specific, so it'll work on any website that uses jQuery. Try it on [Wikipedia](http://en.wikipedia.org) for hilarious results. The idea is based on something I wrote years ago as a creative interpretation of the "99 bottles of beer" challenge: my version introduced a slowly increasing number of typos into each verse, until the last ones were all but unrecognizable. If anyone wants to see it, [here's the original Perl code](https://groups.google.com/forum/message/raw?msg=comp.lang.perl.misc/f5KbGcDE6tw/LrM-Ho2NaoMJ). [Answer] Chicken! ### Score: 46 - 1 (explanation) - 5\17 (votes) = -40 ``` javascript:$(':not(:has())').text('chicken') ``` It simply takes every element with no children and replaces it with the text `'chicken'`. Sample screenshots: [more chicken](https://i.stack.imgur.com/RW7bE.png) [this question chickenified](https://i.stack.imgur.com/p2cyl.png) ![image](https://i.stack.imgur.com/BVYUb.png) [Answer] I don't know why this was downvoted, I like it :) This isn't the shortest, but I think it's pretty: 133 chars* -1 ``` javascript:(function(){setInterval(function(){$("div, span").eq(Math.round(Math.random()$("div, span").length)).hide(500)},90)}()); ``` Ungolfed: ``` javascript:(function(){ window.setInterval(function() { i = Math.round(Math.random() $("div, span").length); $("div, span").eq(i).hide("slow"); } , 90); }()); ``` Explanation: I hope this counts, this script implodes the site instead of exploding it ;) This just picks a random div or span every 90ms and closes it slowly.. [Answer] Because it was not defined if the higher or lower score wins... ``` javascript:$(".vote-down-off").click() ``` Base: 38 Bonis: * +9e72 Permanent damage. ### Final score: 9000000000000000000000000000000000000000000000000000000000000000000000038 Btw, I did not try it. [Answer] ## My pupose 245 chars. Mostly not the shorter, but I like it ;-) ``` javascript:document.body.innerHTML+='<img%20id="bigMsk"%20src="https://i.stack.imgur.com/VWPZg.gif">';document.getElementById('bigMsk').setAttribute('style','z-index:1;opacity:.6;display:block;position:fixed;top:0;left:0;width:100%;height:100%;'); ``` -1: Explanation: * I use the nice offered animated gif image from question, * With the help of CSS, I put them over the page in full page, with a 60% opacity. : ``` document.body.innerHTML+= '<img%20id="bigMsk"%20src="https://i.stack.imgur.com/VWPZg.gif">'; document.getElementById('bigMsk').setAttribute('style', 'z-index:1; opacity:.6; display:block; position:fixed; top:0; left:0; width:100%; height:100%; '); ``` Mostly readable by itself ;-) -10 No JQuery ### Alternative: There is an alternative: ``` javascript:document.body.innerHTML+='<img%20id="bigMsk"%20src="https://i.stack.imgur.com/aTtWM.gif">';document.getElementById('bigMsk').setAttribute('style','z-index:1;opacity:.6;display:block;position:fixed;top:0;left:0;width:100%;height:100%;'); ``` Based on unmodified GIF, found at [Wikimedia Commons: File:Animated fire by nevit.gif](http://commons.wikimedia.org/wiki/File:Animated_fire_by_nevit.gif) Image: ![Image from Wikipedia](https://i.stack.imgur.com/aTtWM.gif) ### Sample: ![enter image description here](https://i.stack.imgur.com/ACvDH.png) [Answer] Ok, I think this should meed the criteria: ``` javascript:document.write("<h1>Exploded</h1>") ``` Replaces the current page with "Exploded" Score: 46 -1 Explaination -10 No jQuery ## 35 [Answer] This one's enjoyable, and causes quite a bit of lag too :D ``` javascript:setInterval(function(){document.body.innerHTML=document.body.innerHTML.replace(/\d+/g,function(){return Math.random()100\|0});},500) ``` It just sets an interval that replaces all strings of digits with a random number from 0 to 100. Twice per second. It creates a bunch of errors, as you might expect, and I could fix it to stop all the 404s when image URLs are changed, but I think it's more fun this way and it's code golf. :D Score: 132 base * -1 explanation * -5 upvote * -10 no jQuery Total score: 116 [Answer] # 165 chars (164 points) -1 for explaination Here's my attempt. It's not particularly short, but it's fun. ``` javascript:r=Math.random;$("a,span,p").each(function(){var a=$(this);a.css({position:"relative"});a.delay(1E4r()).animate({left:9E3r()-4E3,top:9E3r()-4E3},555)}); ``` It slides individual elements off the page in random directions. I specifically included span because of the syntax highlighting (each color has a separate span). ``` r = Math.random; $('a,span,p').each(function () { var t = $(this); t.css({ position: 'relative' }); t.delay(r()10000).animate({ left: r() * 9e3 - 4e3, top: r() * 9e3 - 4e3 }, 555); }); ``` It of course could be shortened by removing some of the tags, but let me know if there are any ways to shorten it without reducing the performance. [Answer] # 181 151 chars - 1 (explanation) - 10 (no jQuery) = 140 points ``` javascript:i=setInterval(function(){for(var a=document;0!==a.childNodes.length;)a=a.childNodes[a.childNodes.length-1];a!==document?a.parentNode.removeChild(a):clearInterval(i)},50); ``` A few more characters can be saved by omiting the `function(){` and using a string instead. Also note the extraction of commonly used properties, e.g., `c='childNodes` allows us to do `z[c]` instead of `z.childNodes`. ``` javascript:h=setInterval('d=z=document;c="childNodes";for(l="length";z[c][l];z=z[c][z[c][l]-1]);z!=d?z.parentNode.removeChild(z):clearInterval(h)',50); ``` I guess I could make less points by using jQuery and not traversing properties, but oh well. Ungolfed: ``` var intervalHandle = setInterval(function() { var lastElement = document; //get last element while (lastElement.childNodes.length !== 0) { lastElement = lastElement.childNodes[lastElement.childNodes.length - 1]; } if(lastElement !== document) { lastElement.parentNode.removeChild(lastElement); } else { clearInterval(intervalHandle); } }, 50); ``` Basically this finds the latest DOM element on the page and removes it. Then keeps doing that for every 50 milliseconds, which I found to be a kind-of-average nice speed to see a page getting ripped from the ground up. It's therapeutic, I swear it. Disclaimer: I had made this some time ago and decided to share it, since it seems appropriate here. The source is at [my GitHub repository](https://github.com/AlphaGit/random-javascript/blob/master/destroy-me/destroyme.js). [Answer] ### Javascript, 281 ``` javascript:$('body').html().split('<code>javascript:').forEach(function (a) {if (a.indexOf("location")a.indexOf("write")a.indexOf("noscript")==-1) try{exec(a.split("</code>")[0].replace(/&#(\d+)/g, function(match, dec) {return String.fromCharCode(dec);}))} catch (e) {}});void 0; ``` It gets every response to the question in the form of `<code>javascript:(stuff)</code>` that doesn't change the location, and runs all of them. [Answer] I like this effect. It basically toggles a slide effect for every div on the site every 1 millisecond. ``` javascript:setInterval(function(){$('div').toggle()},1) ``` Score ``` 56 -1 Explanation -------------- 55 Total ``` ]
[Question] [ The Task This is quite a simple coding task, all your program has to do is place a point on a canvas (or your alternative in another coding language) and connect it to all the dots already placed. Your program must take in one input, the number of dots that should be placed, and output some sort of display with the dots connected. [Example](https://www.dropbox.com/s/bdgyrxsrri2g6u1/CodeGolf.png) Requirements * I have to be able to run it, which means that it has to have a compiler/tool to run it either online, or publicly available to download. * You are allowed to use any library created before this challenge was set, as long as it wasn't designed for the sole purpose of solving this. * This is a shortest code task, which means characters. Comments, code that changes colour (for prettiness) and libraries will be ignored. * Your answer must be unique, don't steal other peoples code, shorten it a few characters and repost it. * It must be able to run in less than 5 minutes, for the values of 5 and 100. It must also use a resolution of at least 200\200 and put each dot in a random location on the canvas using a non-trivial distribution. Current Leaderboard* ``` Flawr - Matlab - 22 - Confirmed Falko - Python 2 - 41 - Confirmed Wyldstallyns - NetLogo - 51 - Confirmed Ssdecontrol - R - 66 - Confirmed 9214 - Red - 81 - Confirmed David - Mathematica - 95 - Confirmed Razetime - Red - 118 - Confirmed ILoveQBasic - QBasic - 130 - Confirmed Adriweb - TI-Nspire Lua - 145 - Confirmed Manatwork - Bash - 148 - Confirmed Doorknob - Python 2 - 158 - Confirmed Kevin - TCL - 161 - Confirmed M L - HPPPL - 231 - Confirmed Manatwork - HTML/JS - 261 - Confirmed - Improved code of Scrblnrd3 Makando - C# - 278 - Confirmed Scrblnrd3 - HTML/JS - 281 - Confirmed Geobits - Java - 282 - Confirmed ``` If I've missed you out, I'm very sorry, just add a comment to your work saying so and I'll add it as soon as I see it =) TL;DR * Input - Number of dots (int, can be hard coded) * Output - Image of randomly placed dots, all connected to each other (graphic) * Winner - Shortest code [Answer] # Java : ~~318 282~~ 265 Because, ya know, Java: ``` class M{public static void main(String[]a){new Frame(){public void paint(Graphics g){int i=0,j,d=640,n=25,x[]=new int[n],y[]=x.clone();for(setSize(d,d);i<n;i++)for(j=0,x[i]=(int)(random()d),y[i]=(int)(random()d);j<i;g.drawLine(x[i],y[i],x[j],y[j++]));}}.show();}} ``` Its just a simple loop that makes random dots and draws lines between the current dot and all previous ones. Example with 25 dots: ![enter image description here](https://i.stack.imgur.com/3gcZv.png) With line breaks and imports: ``` import java.awt.; import static java.lang.Math.; class M{ public static void main(String[]a){ new Frame(){ public void paint(Graphics g){ int i=0,j,d=640,n=25,x[]=new int[n],y[]=x.clone(); for(setSize(d,d);i<n;i++) for(j=0,x[i]=(int)(random()d),y[i]=(int)(random()d); j<i; g.drawLine(x[i],y[i],x[j],y[j++])); } }.show(); } } ``` Edit: Since we're not counting imports, I imported a couple more things to save some characters later. Edit 2: OP added an allowance for hardcoding number of dots. -17 chars :) [Answer] # Matlab (22) ``` gplot(ones(n),rand(n)) ``` It is assumend that n is the number of points, and it looks like this for n=10: ![random graph](https://i.stack.imgur.com/MC8yt.png) `n=6`: ![random](https://i.stack.imgur.com/QKeoA.png) ### Explaination `gplot` is a command for plotting graphs. The first argument is a `n x n` incidence matrix (full of ones, obviously). The second argument should be a `n x 2` matrix with the coordinates of the points, but it does not matter if the second dimension is bigger that 2, so I just generate an `n x n` matrix of random values (which is 2 characters shorter than generating an `n x 2` matrix). ## Links to documentation * [gplot](http://www.mathworks.ch/ch/help/matlab/ref/gplot.html) * [ones](http://www.mathworks.ch/ch/help/matlab/ref/ones.html) * [rand](http://www.mathworks.ch/ch/help/matlab/ref/rand.html) [Answer] # Python 2 - ~~41~~ 35 After importing some libraries as allowed for this challenge ``` from pylab import rand as r from pylab import plot as p from itertools import product as x from itertools import chain as c ``` we can plot some number of connected points with just one line of code: ``` X=r(5,2);p(zip(c(list(x(X,X))))) ``` ![](https://i.stack.imgur.com/FlJj1.png) (The screenshot was generated with 10 points.) [Answer] # Mathematica ~~95~~ 87 With some help from belisarius. ``` CompleteGraph[n, VertexSize -> {2, 2}, VertexCoordinates -> Table[RandomInteger[{0, 199}, 2], {n}]] ``` n=5* ![5](https://i.stack.imgur.com/92QAu.png) --- n=100 Timing: 2.082654 sec ![100](https://i.stack.imgur.com/cVFjG.png) [Answer] # Python 2, 158 Import statements not included in character count, as noted in question ("libraries will be ignored"). ``` from PIL import Image,ImageDraw from random import randint s=[(randint(0,200),randint(0,200))for _ in range(int(input()))] i=Image.new('RGB',(200,200)) [ImageDraw.Draw(i).line((p,q),255)for p in s for q in s] i.show() ``` Sample outputs: n=2 (...): ![n=2](https://i.stack.imgur.com/QOIbk.png) n=10 (looks like fancy 3d thing or something): ![n=10](https://i.stack.imgur.com/udYat.png) n=100 (looks like someone went BLELEEEAARARGHHH with a red pen): ![n=100](https://i.stack.imgur.com/sI96I.png) n=500, 1000, 10000 (runs in about 1.5 seconds, 5-6 seconds, and 3.5 minutes respectively): ![](https://i.stack.imgur.com/tSZWi.png)![](https://i.stack.imgur.com/hjDkV.png)![](https://i.stack.imgur.com/UPlf0.png) Note: the 10000 points one was run with a slightly optimized version that changed line 3 (not including imports) to this: ``` d=ImageDraw.Draw for p in s: for q in s:d.line((p,q),255) ``` Otherwise it would have taken forever. :P Ungolfed: ``` from PIL import Image, ImageDraw from random import randint point_count = int(input()) image_size = 200 points = [(randint(0, image_size), randint(0, image_size)) for _ in range(point_count)] image = Image.new('RGB', (200, 200)) draw = ImageDraw.Draw(image) for start_point in points: for end_point in points: draw.line((start_point, end_point), 255) image.show() ``` [Answer] ## R, 66 This one is borderline cheating but I still think it's within the rules. Set up by loading the `igraph` package with `library(igraph)`, which can be downloaded from CRAN with `install.packages("igraph")`. Then assign the input to variable `N`. As per the rules, these are not counted in the total. ``` G=graph.adjacency(matrix(1,N,N),"un") plot(G,layout=layout.random) ``` ### N = 50 ![enter image description here](https://i.stack.imgur.com/sNyRb.png) Note that this code also draws self-connections. Eliminating them (although there's no rule against them) adds 6 characters: ``` G=graph.adjacency(matrix(1,N,N),"un",diag=F) plot(G,layout=layout.random) ``` ## R, 141 This is an honest-to-goodness solution in base R: ``` p=replicate(2,runif(N)) g=as.matrix(expand.grid(1:N,1:N)) plot.new() apply(g,1,function(i) segments(p[i[1],1],p[i[1],2],p[i[2],1],p[i[2],2])) ``` although you still have to enter `N` by hand. ### N = 50 ![enter image description here](https://i.stack.imgur.com/GOFLU.png) I'm wondering if a `for` loop would be fewer characters than `apply` but I'm happy with what I've got. [Answer] # QBasic or QuickBasic, 130 characters ``` SCREEN 1:RANDOMIZE:N=10:DIM X(100),Y(100):FOR I=1 TO N:X(I)=RND320:Y(I)=RND200:FOR J=1 TO I:LINE(X(I),Y(I))-(X(J),Y(J)):NEXT J,I ``` ### Code variations * If you do not want to be prompted for a seed, replace `RANDOMIZE` with `RANDOMIZE TIMER`. * If you want to be prompted for N, replace `N=10` with `INPUT N` or `INPUT "N";N`. ### Sample runs For `N=5`, tested with QBasic 1.1 running on DOSBox 0.74: ![](https://i.stack.imgur.com/jIeQC.png) For `N=100`, tested with QBasic 1.1 running on DOSBox 0.74: ![](https://i.stack.imgur.com/7iUlz.png) [Answer] # Bash + ImageMagick: 148 characters ``` c=() while((i++<$1)); do p=$[RANDOM%200],$[RANDOM%200] c+=($p) for e in ${c[@]};do d+="line $p $e" done done convert -size 200x200 xc: -draw "$d" x: ``` Sample run: ``` bash-4.3$ time ./line.sh 5 real 0m5.256s user 0m0.137s sys 0m0.017s ``` Sample output: ![5 connected points](https://i.stack.imgur.com/AxQ82.png) Sample run: ``` bash-4.3$ time ./line.sh 25 real 0m3.043s user 0m0.574s sys 0m0.023s ``` Sample output: ![25 connected points](https://i.stack.imgur.com/z8pwv.png) Sample run: ``` bash-4.3$ time ./line.sh 100 real 0m5.662s user 0m11.156s sys 0m0.076s ``` Sample output: ![100 connected points](https://i.stack.imgur.com/KWhxA.png) [Answer] # TCL 161 chars Clearly not going to win, but beats several others presented here, and I think it makes good use of a highly undervalued language. ``` for {set i 0} {$i<10} {incr i} {lappend l [expr rand()291] [expr rand()204]} pack [canvas .c] foreach {x y} $l {foreach {w z} $l {.c create line $x $y $w $z}} ``` ![Example](https://i.stack.imgur.com/mNgI7.png) The default canvas size on my system appears to be 291x204. Not sure why, but using it saves 13 characters. Fairly fast, 400 points in < 5 seconds, 500 in ~10 s. Size and points can be scaled arbitrarily and colors and line styles can be altered, at the cost of characters of course. Un-golfed and using variables to make it clearer and easier to scale and color: ``` set n 20 set width 500 set height 500 set bg_color black set line_color white for {set i 0} {$i < $n} {incr i} { lappend points [expr rand() * $width] [expr rand() * $height] } canvas .c -width $width -height $height -background $bg_color pack .c foreach {x1 y1} $points { foreach {x2 y2} $points { .c create line $x1 $y1 $x2 $y2 -fill $line_color } } ``` [Answer] ## [TI-Nspire] Lua - ~~145~~ ~~135~~ 130 (Updated fixed version) ![Screenshot with n=10](https://i.stack.imgur.com/QoVLS.png) "Importing" math.random as "r", first, as allowed : `r=math.random` Actual code : ``` function on.paint(g)t={}for b=1,2n-1,2 do t[b]=r(318)t[b+1]=r(212)for c=1,b-1,2 do g:drawLine(t[b],t[b+1],t[c],t[c+1])end end end ``` Note : This code works on the TI-Nspire calculators (TI added Lua scripting to recent OSes of this platform, with an even-based API allowing users to graph stuff etc. for example.)* It can also be [tried online here](http://bwns.be/jim/WEBspire/editor.html) (just erase the demo script and prepend mine with `n=10` for example) [Answer] # [Red](http://www.red-lang.org), 118 bytes ``` a: collect[loop n[keep random d: 200x200]] view[base d draw collect[foreach p a[foreach q a[keep reduce['line p q]]]]] ``` This was fun to figure out. Thanks to [Toomas Vooglaid](https://github.com/toomasv) on Gitter and 9214 for helping with this. `n` is hardcoded. -1 byte from Bubbler. -2 bytes from Galen Ivanov. ## Screenshots [![enter image description here](https://i.stack.imgur.com/l3xdP.png)](https://i.stack.imgur.com/l3xdP.png) [![enter image description here](https://i.stack.imgur.com/5crde.png)](https://i.stack.imgur.com/5crde.png) [Answer] # C# Windows forms, 268 ``` static void k(int n,int s){var f=new Form{Height=s+50,Width=s+25};f.Paint+=(u,v)=>{var r=new Random();var p=new Point[n];while(n>0)p[--n]=new Point(r.Next(s),r.Next(s));foreach(var a in p)foreach(var b in p)f.CreateGraphics().DrawLine(Pens.Tan,a,b);};f.ShowDialog();} ``` N=5 ![Plot using 5 points](https://i.stack.imgur.com/a6VxU.png) N=50 ![Plot using N=50](https://i.stack.imgur.com/GyMRo.png) # Full code is given below ``` using System; using System.Drawing; using System.Windows.Forms; namespace WindowsFormsApplication2 { static class Program { static void Main() { k(50, 200); } static void k(int n, int s) { var f = new Form {Height = s + 50, Width = s + 25}; f.Paint += (u, v) => { var r = new Random(); var p = new Point[n]; while (n > 0) p[--n] = new Point(r.Next(s), r.Next(s)); foreach (var a in p) foreach (var b in p) f.CreateGraphics().DrawLine(Pens.Tan, a, b); }; f.ShowDialog(); } } } ``` [Answer] # [Red](http://www.red-lang.org), 81 bytes ``` ?(draw d: 200x200 loop n: 10[foreach x append[]y: random d[repend[]['line x y]]]) ``` [Try it locally in REPL](https://www.red-lang.org/p/download.html) [![enter image description here](https://i.stack.imgur.com/11rsb.png)](https://i.stack.imgur.com/11rsb.png) [Answer] # HTML/JS, 210, thanks to manatwork ``` <canvas id=q /><script>c=q.getContext("2d");r=Math.random;e=prompt(a=[]);for(i=0;i<e;i++){a[i]={x:r()300,y:r()150};for(j in a)c.beginPath()+c.moveTo(a[i].x,a[i].y)+c.lineTo(a[j].x,a[j].y)+c.stroke()}</script> ``` [JSFiddle](http://jsfiddle.net/e866azzs/9) [Answer] # C# WPF ~~306~~ 296 ``` partial class W:Window{public W(){InitializeComponent();int x=5,i=0,j,z=200;int[]f=new int[x],s=new int[x];var r=new Random();var X=new Grid();AddChild(X);for(;i<x;i++){f[i]=r.Next(z);s[i]=r.Next(z);for(j=i;j>=0;)X.Children.Add(newLine(){X1=s[j],Y1=f[j--],X2=s[i],Y2=f[i],Stroke=Brushes.Red});}}} ``` I would like to say that I could remove Stroke=Brushed.Red. But Sadly that means that I am painting transparent lines, and my Guess is that it wouldn't really count. :P I can also shave of a couple of bytes by just creating a grid in the XAML view. But that seemed unfair, so I stripped the XAML to become a blank canvas. (I don't count the XAML as bytes...) ``` partial class W:Window { public W() { InitializeComponent(); int x=5,i=0,j,z=200; int[]f=new int[x],s=new int[x]; var r = new Random(); var X = new Grid(); AddChild(X); for (;i<x;i++) { f[i]=r.Next(z); s[i]=r.Next(z); for (j=i;j>=0;) X.Children.Add(new Line() { X1 = s[j], Y1 = f[j--], X2 = s[i], Y2 = f[i], Stroke = Brushes.Red }); } } } ``` XAML ``` <Window x:Class="W" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="350" Width="525"> </Window> ``` # 5 ![5](https://i.stack.imgur.com/01baZ.jpg) # 100 ![100](https://i.stack.imgur.com/PGnXN.jpg) [Answer] # HPPPL, ~~231~~ 220 (HP Prime Programming Language for the HP Prime color graphing calculator) golfed it down. 11 fewer chars by drawing all possible new lines right after every new point creation. Only two nested loops instead of the previous three. ``` export c(n) begin rect();local g,h;a:=makemat(0,n,2);for g from 1 to n do a(g,1):=ip(random(1,320));a(g,2):=ip(random(1,240));if g>1 then for h from 1 to g-1 do line_p(a(h,1),a(h,2),a(g,1),a(g,2));end;end;end;freeze;end; ``` Ungolfed (270 chars): ``` export randomnet(n) begin rect(); local g,h; a:=makemat(0,n,2); for g from 1 to n do a(g,1):=ip(random(1,320)); a(g,2):=ip(random(1,240)); if g>1 then for h from 1 to g-1 do line_p(a(h,1),a(h,2),a(g,1),a(g,2)); end; end; end; freeze; end; ``` examples: c(10) [![connect_10_points_HPPPL](https://i.stack.imgur.com/0jQ97.png)](https://i.stack.imgur.com/0jQ97.png) [![connect_10_points_HPPPL_2](https://i.stack.imgur.com/UK7af.png)](https://i.stack.imgur.com/UK7af.png) c(30) [![connect_30_points_HPPPL](https://i.stack.imgur.com/dqcSC.png)](https://i.stack.imgur.com/dqcSC.png) The HP Prime color graphing calculator has a 320x240 pixel color display. [![enter image description here](https://i.stack.imgur.com/xLV1t.png)](https://i.stack.imgur.com/xLV1t.png) An emulator that also works with the connectivity kit is available at the HP website or here: <http://www.hp-prime.de/en/category/6-downloads> ... still waiting for the hardware to arrive. Update on the execution time will follow. Today my HP Prime arrived. Here is the execution time for n=100 on an actual calculator: [![average execution time](https://i.stack.imgur.com/CV3hS.png)](https://i.stack.imgur.com/CV3hS.png) Around 0.65 s for n=100. The emulator is about 4 times as fast (around 0.178 s) on my Core i5 2410M laptop. [Answer] ## NetLogo, 51 bytes ``` crt 9 [create-links-with other turtles fd random 9] ``` Replace 9s with other constants or variables as needed. ![NetLogo output](https://i.stack.imgur.com/AWrtI.png) [Answer] # [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 17 chars Imports (excluded from character count): ``` "exec('global r,p;from pylab import rand as r,plot as p')".E\ ``` --- ``` ‚Äôp(≈í¬¨(r(,2))‚Äô.E ``` Beats all other answers. Port of [Falko's Python answer](https://codegolf.stackexchange.com/a/36634). Go upvote him! Input is hard-coded before the first `,`. ``` ‚Äô...‚Äô.E # trimmed program .E # evaluate... ‚Äô...‚Äô # "p(zip(r(num,2)))"... .E # as Python code ==================== p(zip(r(num,2))) # full program p( ) # display plot with lines connecting all points at coordinates in ordered pairs... * # in... zip( ) # each element of... * # first element of... r( , ) # array of... num # input... r( ) # arrays each containing... 2 # literal... r( ) # random numbers from 0 to 1, half-inclusive... zip( ) # paired with corresponding element in... * # second element of... r( , ) # array of... num # input... r( ) # arrays each containing... 2 # literal... r( ) # random numbers from 0 to 1, half-inclusive ``` # Character scoring abuse (actually longer), 20 characters ``` "ÒôïöúØ§Ûãí≠¶ïüë®•"√á6¬∞Œ≤∆µ6B√é.:.E ``` --- ``` "..."√á6¬∞Œ≤∆µ6B√é.:.E # trimmed program .E # evaluate... √á # list of charcodes of... "..." # literal... Œ≤ # converted from list of base-10 values of base... ¬∞ # 10 to the power of... 6 # literal... Œ≤ # digits to decimal... B # in base... ∆µ6 # 107... .: # with all... √é # 0... .: # s replaced with... √é # input ==================== p(zip(r(num,2))) # full program p( ) # display plot with lines connecting all points at coordinates in ordered pairs... * # in... zip( ) # each element of... * # first element of... r( , ) # array of... num # input... r( ) # arrays each containing... 2 # literal... r( ) # random numbers from 0 to 1, half-inclusive... zip( ) # paired with corresponding element in... * # second element of... r( , ) # array of... num # input... r( ) # arrays each containing... 2 # literal... r( ) # random numbers from 0 to 1, half-inclusive ``` [Answer] # PostScript, 48 bytes ``` 00000000: 8814 3292 6c7b 7261 6e64 887f 9204 7d92 ..2.l{rand....}. 00000010: 837b 7b92 6b92 1a92 1992 1a34 9252 7b92 .{{.k......4.R{. 00000020: 4e92 6392 a792 4d7d 9283 7d92 657d 92a3 N.c...M}..}.e}.. ``` Number of points is in the second byte (here it is 0x14 = 20 points). Un-tokenized version: ``` 20 % number of points 2 mul{rand 127 and}repeat % random points on stack { { moveto % move to top point on stack count copy % duplicate stack count 4 idiv{ % for each duplicated point gsave lineto stroke % draw a line to it grestore % (removing it from the stack) }repeat }loop }stopped % stop when stack is empty ``` [![output](https://i.stack.imgur.com/QvKYf.png)](https://i.stack.imgur.com/QvKYf.png) ]
[Question] [ The challenge is to golf a program when given a string composed of any number of asterisks, then a comma, than any number of asterisks, say which side has more. The asterisk-strings can be empty. # Output `0` for ties. `1` for the left. `2` for the right. # Examples Input: `*,` Output: `2` Input: `,` Output: `1` Input: `,` Output: `0` Input: `,` Output: `0` # Scoring This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer wins. [Answer] # [Python 2](https://docs.python.org/2/), 25 bytes ``` lambda s:cmp(s[::-1],s)%3 ``` [Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYKjm3QKM42spK1zBWp1hT1fh/Wn6RQo5CZp5CUWJeeqqGqaYVlwJIrAhNTCGxuDi1qEQhTUNdS11BC6hHW0FdRx1EgvlFmgq2tgrRBjoKhjoKRrHRIItydIDCsf8B "Python 2 – Try It Online") [Answer] # [///](https://esolangs.org/wiki////), ~~60~~ ~~64~~ 28 bytes ``` /,/,//,/2//,/1//,/0//// ``` [Try it online!](https://tio.run/##K85JLM5ILf7/X19LR0tfR18fSBrpAzn6hkC2vgGQqa//X0sLKAsC/wE "/// – Try It Online") Found out most of my program was unnecessary, -32 bytes. I made this program when I was learning the language, and decided to post it as a question. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` Â.S(3% ``` [Try it online!](https://tio.run/##yy9OTMpM/f//cJNesIax6v//WlpaOkAMAA "05AB1E – Try It Online") ### How? Note that `','` is greater than `''`. ``` Â.S(3% Â - input, reversed(input) (say a, b) .S - compare: 1 if a > b; -1 if a < b; 0 if a = b ( - negate 3 - push three % - modulo ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~65~~ \$\cdots\$ ~~54~~ 47 bytes Saved a 10 bytes thanks to [dingledooper](https://codegolf.stackexchange.com/users/88546/dingledooper)!!! Saved a byte thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!! Saved 7 bytes thank to [l4m2](https://codegolf.stackexchange.com/users/76323/l4m2)!!! ``` f(c){c=strlen(c)-strspn(c,"")2;c=c>1?2:c!=1;} ``` [Try it online!](https://tio.run/##TVDBbsMgDL33KzxLlYASLcm0Q8foDtO@osmhomRL1KUR5IAW5dszF5GtSIZn/J4fxmSfxixLwwyfjPaju9iecEbID4QkCuSiVEabQ/FWvpgHXah5@T61PeMwbYCW@To5Ae5Yg4YJq/BRVmH/TvGMEu7zJ5zVnWK0fvRJJYSQFALJUMi4xwu84aRq@xFsGGwY7TnKYCplIXOZJ0JzdcBurI6KuaLjFXz7Y68Ni178MWXRnyvY7bp1iNUgkDTRj13N1V9xcFRuGFa49RVCdoDtGQj2NORKlxAkfQT10P8v7eq1zbyZl18 "C (gcc) – Try It Online") [Answer] # Gema, 20 characters ``` ,=@cmps{;;2;0;1} ``` Sample run: ``` bash-5.0$ echo -n ',*' \| gema ',=@cmps{;;2;0;1}' 2 ``` [Try it online!](https://tio.run/##S0/NTfz/X0tHy9YhObeguFrLWsvayNrA2rAWKKoFFAcCAA "Gema – Try It Online") / [Try all test cases online!](https://tio.run/##lZA9T8MwEIbn@FccVui1VqN8rJaldmBgQmINEUodl1ZtE8t2JaTQ3x7sBEoHGBh89/ruPd1jb2q7Gxolj7VRkKzBKeteZW2VmJOoRMbY0h@GlcACvyvhluNNPxSysbD8kgtCtNm3bgv4AfdJnln4JRc@vrQI@Njqs/P5WdnzMYiHd62kU42XTwckZNsZ2AeTj0Dj/u4KWq6qC@XQdCQy47Sg8RyU3HWQBOs4Rf22tNMufVOnOrVGjgJw8PhiJU/a9owzXvCM55cBYUEJif7xgOsaGk8QQfU/jFPbg0KAK8sbnxB/WasKZrPpJeETAlTTtWr4BA "Bash – Try It Online") [Answer] # [Bash](https://www.gnu.org/software/bash/) + Standard utilities, 28 bytes ``` dc<<<1`tr , 1d`1-ddv/3+3%p ``` [Try it online!](https://tio.run/##S0oszvj/PyXZxsbGMKGkSEFLR8EwJcFQNyVFq0zfWNtYteD/fy0tLR0g1gIA "Bash – Try It Online") [Answer] # [sed](https://www.gnu.org/software/sed/) -E, 30 bytes ``` s/(.),\1/0/;s/.+0/1/;s/0.+/2/ ``` [Try it online!](https://tio.run/##K05N0U3PK/3/v1hfQ09LUyfGUN9A37pYX0/bQN8QxDDQ09Y30v//XwsEdID4X35BSWZ@XvF/XVcA "sed – Try It Online") [Answer] # [K (ngn/k)](https://bitbucket.org/ngn/k), ~~17~~ 16 bytes Solution: ``` {2/c<\|c:#'","\x} ``` [Try it online!](https://tio.run/##y9bNS8/7n2ZVbaSfbFOTbKWsrqSjFFNR@z9NXUNJS0tLB4i1lKzBTCgFFjBUBqrT/P8fAA "K (ngn/k) – Try It Online") Explanation: ``` {2/c<\|c:#'","\x} / the solution -> e.g. 1 e.g. 2 e.g. 3 { x} / lambda taking implicit 'x' -> "*," "," "," ","\ / split string on comma -> ("";"") ("";"") ("";"") #' / count length of each -> 3 4 3 0 3 3 c: / store as c -> 3 4 (noop) 3 0 3 3 \| / reverse it -> 4 3 0 3 3 3 c< / is c less than this? -> 1 0 0 1 0 0 2/ / convert from base 2 -> 2 1 0 ``` Extra:* * 13 bytes if it doesn't need to be a function `2/c<\|c:#'","\` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 6 bytes ``` ,ṚMḄ2c ``` A monadic Link accepting a list of characters which yields an integer in \$[0,2]\$. [Try it online!](https://tio.run/##y0rNyan8/1/n4c5Zvg93tBgl////X11LS0sHiNUB "Jelly – Try It Online") ### How? Note that `','` is greater than `''`. ``` ,ṚMḄ2c - Main Link: s e.g.: "," "," "," Ṛ - reverse (s) "," "," "," , - pair (s) with (that) [",",","] [",",","] [",",","] M - indices of maximal values [2] [1] [1,2] Ḅ - convert from base 2, say x 2 1 4 2 - two 2 2 2 c - (2) choose (x) - i.e. binomial(2,x) 1 2 0 - implicit print (a list with a single element prints the element) ``` [Answer] # [Perl 5](https://www.perl.org/) + `-pl`, 21 bytes ``` /,/;$_=$`cmp$';s;-1;2 ``` [Try it online!](https://tio.run/##K0gtyjH9/19fR99aJd5WJSE5t0BF3brYWtfQ2uj/fy0tLR0g1uICMbigPC6df/kFJZn5ecX/dQtyAA "Perl 5 – Try It Online") [Answer] # [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 9 bytes ``` (⊥⍋\|⍒)⊢⍮⌽ ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/X@NR19JHvd01j3onaT7qWvSod92jnr3/0xQetU1QeNTb96ir@dB640dtEx/1TQ0OcgaSIR6ewUB5dS0tLR0g1lLngnLgDKigjrqOOgA "APL (Dyalog Extended) – Try It Online") ### How it works ``` (⊥⍋\|⍒)⊢⍮⌽ ⍝ left ',' \| right ',' \| equal ',' ⊢⍮⌽ ⍝ Length-2 nested vector of self and reverse ⍋ ⍝ Grade up; order of indices to make it ascending-sorted ⍝ 1 2 \| 2 1 \| 1 2 ⍒ ⍝ Grade down; order of indices to make it descending-sorted ⍝ 2 1 \| 1 2 \| 1 2 \| ⍝ Right modulo left ⍝ 0 1 \| 1 0 \| 0 0 ⊥ ⍝ From base 2 to integer ⍝ 1 \| 2 \| 0 ``` [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~20~~ ~~19~~ 13 bytes[SBCS](https://en.wikipedia.org/wiki/SBCS) Whooping -6 thanks to @Bubbler. ``` (⊃3\|⍒-⍋)⊂,⊂∘⌽ ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qZr7Co7YJCgZc1cY1Gnb6jzpmPOqdpAtldGs@6t2q8ahnL5DSrAUpedTVrAFSgCmnAZQCymOTQ5WqRpb7j6atq0kHiEGW9@z9nwZ22qPePqCaQ@uNH7VNBDo4OMgZSIZ4eAYD5dW1tLR0gFhLnQvKgTOggjrqOuoA "APL (Dyalog Unicode) – Try It Online") This should be golfable as there are some things I am repeating there but I am not sure how to do it yet. ## [APL (Dyalog Unicode)](https://www.dyalog.com/), 19 bytes[SBCS](https://en.wikipedia.org/wiki/SBCS) ``` {3\|×1+(2×⍵⍳',')-≢⍵} ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qZr7Co7YJCgb/q41rDk831NYwOjz9Ue/WR72b1XXUNXUfdS4C8mr/p4FVPerte9TV/Kh3zaPeLYfWGz9qmwg0ITjIGUiGeHgGA1Wpa2lp6QCxljoXlANnQAV1gOYCAA "APL (Dyalog Unicode) – Try It Online") [Answer] # JavaScript (ES6), ~~26~~ 25 bytes Saved 1 byte thanks to @tsh* Taking advantage of the looser output rules: this versions returns `0` for ties, `undefined` for left or `` for right. ``` s=>(s+0)[s.search`,`2+1] ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1k6jWNtAM7pYrzg1sSg5I0EnQctI2zD2f3J@XnF@TqpeTn66RpqGkpaWlg4QaylpanJhkcIhjF0DSPV/AA "JavaScript (Node.js) – Try It Online") --- # JavaScript (ES6), 31 bytes [Returns a Boolean value](https://codegolf.meta.stackexchange.com/a/9067/58563) instead of 0 / 1. ``` s=>([a,b]=s.split`,`,a<b?2:a>b) ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1k4jOlEnKda2WK@4ICezJEEnQSfRJsneyCrRLknzf3J@XnF@TqpeTn66hnaahpKWlpYOEGspaWpyYZPDJY5DC0j9fwA "JavaScript (Node.js) – Try It Online") [Answer] # [Ruby](https://www.ruby-lang.org/) -nl, 18 bytes ``` ~/,/;p ($`<=>$')%3 ``` [Try it online!](https://tio.run/##KypNqvz/v05fR9@6QEFDJcHG1k5FXVPV@P9/LS0tHSDm0uHSgjK1uCAMLqgMlATxgGyQKJeO1r/8gpLM/Lzi/7p5OQA "Ruby – Try It Online") Takes input from STDIN. Compares the regex match groups `$`` and `$'`, which are set equal to everything on the left and right of the comma, respectively. [Answer] # [Io](http://iolanguage.org/), 51 bytes Mod3 doesn't work in Io. Too bad. ``` method(x,I := -x compare(x reverse);if(I== -1,2,I)) ``` [Try it online!](https://tio.run/##y8z/n6ZgZasQ8z83tSQjP0WjQscTxNetUEjOzy1ILErVqFAoSi1LLSpO1bTOTNPwtAVKGuoY6Xhqav5P01DS0tLSAWItJU2FgqLMvJKcPC6oKKYIhjIkNf8B "Io – Try It Online") [Answer] # [brainfuck](https://github.com/TryItOnline/brainfuck), 57 bytes ``` -[>>,<--[>-<++++++]>-]<+[<<,]>[<-->+[<+>+]]-[<+>-----]<-. ``` [Try it online!](https://tio.run/##HYnBCYBAEAML2osVhDSy5KGCIIIPwfrXPeczA7M963kf735VIaVBtMD4sWBGksPKPuoOhY1pTEwsVR8 "brainfuck – Try It Online") It spreads `` on the tape and checks if the second branch went past the first. [Answer] # [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~15~~ 13 bytes ``` (.),\1$ \+ ``` [Try it online!](https://tio.run/##K0otycxLNPyvquGe8F9DT0tTJ8ZQhYsrRkv7/38tLS0dLTDggjHBDCgPJsilAwA "Retina – Try It Online") If the right-hand-side has an equal or less number of ``'s, then those ``'s are removed from both sides, along with the `,`. Then the number of runs of ``'s are counted. [Answer] # [Japt](https://github.com/ETHproductions/japt), ~~9~~ 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) [Returns `true/false` instead of `1/0`](https://codegolf.meta.stackexchange.com/a/9067/58563) ``` >Ô?2:U<Ô >Ô?2:U<Ô :Implicit input of string U > :Greater than Ô : U reversed ? :If true 2 : Literal 2 : :Else U<Ô : U less than U reversed? ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=PtQ/MjpVPNQ&footer=wlU&input=IioqKioqLCoqKioqIg) # Original, 9 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) 5 bytes just to handle the I/O requirements :\ ``` q, mÊrÎu3 ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=cSwgbcpyznUz&input=IioqKioqKiwqKioqKiI) ``` q, mÊrÎu3 :Implicit input of string q, :Split on "," m :Map Ê : Length r :Reduce by Î : Sign of difference u3 :Positive modulo 3 ``` If we could take a space delimited string as input then -2 bytes: ``` ¸mÊrÎu3 ``` If we could take an array as input then -1 more byte: ``` mÊrÎu3 ``` And, if we could use any 3 distinct values for the output then -2 more bytes: ``` mÊrÎ ``` [Answer] # Java 10, ~~74~~ ~~51~~ 50 bytes ``` s->(Long.signum(s.indexOf(44)2-s.length()+1)+3)%3 ``` -24 bytes thanks to @OlivierGrégoire. [Try it online.](https://tio.run/##jY7LCsIwEEX3/YpBEJLUBnzsin6Bj4VLcRHTWFPTqTipKNJvr/G1bmcxzONy7i3UTSVFdm61U0SwUhafEYBFb65HpQ2s3yuAqzAHzbb@asNAPA3XJgqNvPJWwxoQ5i0lC7YMSkk2x7pkJC1m5r45stmMi0lC0hnM/YnxeMzjKR9O2/QNudQHFyA/1q2yGZQhyc9utwfFvzG2D/KmlFXt5SW8vEOGUrOBEGIkPjXgn2zd0l7CnrS@pp26bsPRH9JETfsC) Explanation:* ``` s->{ // Method with String parameter and long return-type Math.signum( // Take the signum of: s.indexOf(44) // The index of ',' (codepoint 44) 2 // multiplied by 2 -s.length() // Subtract the entire length of the input +1 // And add 1 +3) // Then increase that result by 3 %3 // And take modulo-3 on it ``` [Answer] # [Ruby](https://www.ruby-lang.org/) -n, ~~21~~ 20 bytes ``` p (~/,/2<=>~/.$/)%3 ``` [Try it online!](https://tio.run/##KypNqvz/v0BBo05fR1/LyMbWrk5fT0VfU9X4/38tLS0dIObS4dKCMrW4IAwuqAyUBPGAbJAol47Wv/yCksz8vOL/unkA "Ruby – Try It Online") [Answer] # [J](http://jsoftware.com/), ~~19~~ 18 bytes ``` 3\|i.&','@--:@<:@# ``` [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/jWsy9dTUddS1HHR1rRxsrByU/2v@T1NQ19LS0gFidS44G4kJ5eioAwA "J – Try It Online") ### How it works ``` 3\|i.&','@--:@<:@# -:@<:@# halved (length-1) of list (where , would be in a balanced list) i.&',' position of the , @- signum'd difference between both 3\| mod 3 ``` ## Alternative version, 19 bytes This inserts `-` and `+` between the bit mask of the string: `, -> 1 1 0 1 -> 1 + (1 + (0 - 1)))` to get the difference between both sides. Then both signum and mod 3 like other solutions. ``` 3\|[:''-`+@.[/@:=] ``` [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/jWuirbTUtdR1E7Qd9KL1HaxsY/9r/k9TUNfS0tIBYnUuOBuJCeXoqAMA "J – Try It Online") ### How it works ``` 3\|[:''-`+@.[/@:=] '' =] '*,' -> 1 1 1 0 1 -`+@.[ a function that chooses - or + based on the left argument /@: puts this function inbetween: 1+(1+(1+(0-1))) = 2 [:* signum: 2 -> 1 3\| mod 3 ``` [Answer] # [Befunge-93](https://github.com/catseye/Befunge-93), 31 bytes ``` 2>1~:1+v p^_"$"2 0 .@^-","_$2\- ``` [Try it online!](https://tio.run/##S0pNK81LT/3/38jOsM7KULuMqyAuXklFyUjBgEvPIU5XSUcpXsUoRvf/fy0tLR0gBgA "Befunge-93 – Try It Online") After initially pushing `2` to the stack, we push `1` for every `` we encounter. After finding the `,`, we start popping them instead. When we run out of input we subtract the top of the stack from 2, resulting in the correct output values. [Answer] ## Excel, ~~44~~ 40 Bytes ``` =MOD(3-SIGN(1+LEN(A1)-2FIND(",",A1)),3) ``` Finds the difference between Total Length + 1 and twice the position of the comma (Negative: Left; Zero: Tie; Positive: Right), use `SIGN` to convert these into `-1`, `0` and `1`. Then subtract this from 3 to give `4`/`0`/`2`, and take the Modulo Base 3 (`1`, `0`, `2`) Old version: 44 Bytes ``` =MID(102,2+SIGN(1+LEN(A1)-2FIND(",",A1)),1) ``` Finds the difference between Total Length + 1 and twice the position of the comma (Negative: Left; Zero: Tie; Positive: Right), use `SIGN` to convert these into `-1`, `0` and `1`, add 2 (`1`, `2`, `3`), and then use `MID` to take the first, second or third digit from `102`, respectively. (Using `MID` saved 3 bytes over using `CHOOSE`) I also experimented with a more maths-based approach (Multiply the Sign by 1.5, round it in the Positive direction with `CEILING`, then take the Absolute value), but that was 51 bytes instead. [Answer] # [Python 3](https://docs.python.org/3.8/), 56 60 bytes -4 bytes thanks to math junkie A third approach to this in python. ``` def f(x):a,b=x.split(',');return(1,0,2)[((a<b)-(a>b))+1] ``` [Try it online!](https://tio.run/##K6gsycjPM/7/PyU1TSFNo0LTKlEnybZCr7ggJ7NEQ11HXdO6KLWktChPw1DHQMdIM1pDI9EmSVNXI9EuSVNT2zD2f0FRZl6JRpqGupaWlo6WlrqmJhdCCEMAQwRThZYOqgIQ7z8A "Python 3 – Try It Online") [Answer] # [C (gcc)](https://gcc.gnu.org/) - 67 bytes This is a complete program and can be compiled with gcc. Input is the first command line argument and output is the exit status. ``` main(u,v)intv;{u=strlen(++v)-strspn(v,"")2;exit(u>1?2:u!=1);} ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), 83 bytes ``` x;f(charz){charZ,W;for(Z=z;44-Z++;);for(W=Z;W++;)Z--;x=!!x((x=z-Z+1)<0?1:2);} ``` [Try it online!](https://tio.run/##NYxLCsIwEIav0gYKk0kGrHTlGDxGIXRTItEurBKlhBbPHpuAi@F/MZ@jm3MpRfbg7mPAVW5Frcae/TOANSt3HaFVimVpemMZ@xwtEUdT1xEBolnJqlaeD5f2dJT8TdP8qR7jNEM2ThcsLnLLDF6U0kSO5SvsswfhYRDNexCyMlVzHWahcdEe9ofMSoio98Ni/inpHw "C (gcc) – Try It Online") # [C (gcc)](https://gcc.gnu.org/), 58 bytes Thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat) for this shorter version. ``` f(z,Z)long z,Z;{Z-=strlen(Z=index(z,44))+z-1;z=Z<0?2:!!Z;} ``` [Try it online!](https://tio.run/##NYzBCoMwEER/JQaE3XUDbfHUNPQ/ghdJjRVsLFGkKP32NC30MPCGx4xTvXMpedjY4jiFXmTQu1VmXuLYBbBmCLfulX1dI1abOurN2MvhejoXhdXvNIRFPNohwBccu3sbiVbc/RRBr1XFSjmNz5i1B@mhkeXcSBRGlLcmSKaVPeQB5q9ERJxDP/i3xB8 "C (gcc) – Try It Online") [Answer] # Excel, ~~64~~ ~~63~~ 62 bytes ``` =IF(LEN(A1)+1=2FIND(",",A1),0,IF(LEN(A1)<2FIND(",",A1),1,2)) ``` -1 byte thanks to Dominic van Essen -1 byre thanks to Chronocidal [Answer] # [PHP](https://php.net/), ~~55~~ ~~51~~ 47 bytes ``` fn($s)=>(3+(($a=explode(',',$s))[0]<=>$a[1]))%3 ``` [Try it online!](https://tio.run/##K8go@G9jX5BRwKWSZvs/LU9DpVjT1k7DWFtDQyXRNrWiICc/JVVDXUddByihGW0Qa2Nrp5IYbRirqalq/N@aiys1OSNfQSVNQ0lLS0sHiLWUNPWUYvKUrFFlsItiVQ5X@x8A "PHP – Try It Online") This is the best I have so far.. Gosh, longer than Java and C :O EDIT: saved 4 bytes using value of `$v`, now shorter than C! EDIT2: thanks a lot to 640KB for finding the finely elegant way to have the right numbers! -4 bytes Much shorter with only distinct values instead of fixed numbers requirement: # [PHP](https://php.net/), 39 bytes ``` fn($s)=>($a=explode(',',$s))[0]<=>$a[1] ``` [Try it online!](https://tio.run/##K8go@G9jX5BRwKWSZvs/LU9DpVjT1k5DJdE2taIgJz8lVUNdR10HKKgZbRBrY2unkhhtGPvfmosrNTkjX0ElTUNJS0tLB4i1lDT1lGLylKxRZbCLYlUOV/sfAA "PHP – Try It Online") [Answer] # [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 62 bytes ``` lambda x:y.index(max(y))+1if len({*(y:=x.split(","))})>1else 0 ``` [Try it online!](https://tio.run/##VY/BisMgEIbP61MMc1KbhqR7KQF772lfoFCy1FAhNRInkFD67Fm1mN0VdHT@b2Z@3UL3wX4e3bh26rL27eP71sLcLKWxNz3zRzvzRYhdbTroteVPyZdGzaV3vSGOBQrxEqda915DtZL25EEBIp6tm6gBKWURtvz4miglDuyPsmVr9p/fhCoLv2wVujPWDSPEcWBsij5bulgUDYOwrsYWcB0mCo4ishGEIgNBCmfpaTSOZ9NZfpcaSzxeM5R9hK8nzI2JiMNwvz9hAV18iRxBqdTqTa8/ "Python 3.8 (pre-release) – Try It Online") I know that there is a shorter python solution already posted, but `cmp` doesn't exist in python 3. And don't bother trying to use bitwise operators to increment the value... it ends up being the same byte count. [Answer] # [Ruby](https://www.ruby-lang.org/) `-nlaF,`, 22 bytes ``` p ($F[0]<=>$F[1]\|\|1)%3 ``` [Try it online!](https://tio.run/##KypNqvz/v0BBQ8Ut2iDWxtYOSBvG1tQYaqoa//@vpaWlA8RaXCAGF5THpcMFov7lF5Rk5ucV/9fNy0l00wEA "Ruby – Try It Online") ]
[Question] [ # Background A [super-prime](https://en.wikipedia.org/wiki/Super-prime) is a prime number whose index in the list of all primes is also prime. The sequence looks like this: > > 3, 5, 11, 17, 31, 41, 59, 67, 83, 109, 127, 157, 179, 191, ... > > > This is [sequence A006450 in the OEIS](https://oeis.org/A006450). # Challenge Given a positive integer, determine whether it is a super-prime. # Test Cases ``` 2: false 3: true 4: false 5: true 7: false 11: true 13: false 17: true 709: true 851: false 991: true ``` # Scoring This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in each language wins. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes ``` ÆRÆNċ ``` [Try it online!](https://tio.run/##y0rNyan8//9wW9DhNr8j3f8Ptz9qWgNE7v//R0cb6yiY6igYGgKxuY6CuYGljoKlpWGsDpdCtJGOgomOggJQ2BCoysLUUAEEYmMB "Jelly – Try It Online") ### How it works ``` ÆRÆNċ Main link. Argument: n ÆR Prime range; yield the array of all primes up to n. ÆN N-th prime; for each p in the result, yield the p-th prime. ċ Count the occurrences of n. ``` [Answer] ## Mathematica, ~~26~~ 23 bytes Thanks to user202729 for saving 3 bytes. ``` PrimeQ/@(#&&PrimePi@#)& ``` This makes use of the fact that Mathematica leaves most nonsensical expressions unevaluated (in this case, the logical `And` of two numbers) and `Map` can be applied to any expression, not just lists. So we compute the `And` of the input and its prime index, which just remains like that, and then we `Map` the primality test over this expression which turns the two operands of the `And` into booleans, such that the `And` can then be evaluated. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes ``` ÆRi³ÆP ``` [Try it online!](https://tio.run/##y0rNyan8//9wW1Dmoc2H2wL@//9vaGkIAA "Jelly – Try It Online") Uses the same technique as my Japt answer: Generate the primes up to n, get the index of n in that list, and check that for primality. If n itself is not prime, the index is 0, which is also not prime, so 0 is returned anyway. [Answer] # [Japt](https://github.com/ETHproductions/japt), ~~13~~ 11 bytes ``` õ fj bU Ä j ``` [Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=9SBmaiBiVSDEIGo=&input=OTkx) ### Explanation This is actually very straight-forward, unlike my original submission: ``` õ fj bU Ä j Uõ fj bU +1 j Ungolfed Implicit: U = input integer Uõ Generate the range [1..U]. fj Take only the items that are prime. bU Take the (0-indexed) index of U in this list (-1 if it doesn't exist). +1 j Add 1 and check for primality. This is true iff U is at a prime index in the infinite list of primes. Implicit: output result of last expression ``` [Answer] # Regex (Perl / PCRE), ~~55~~ ~~54~~ 53 bytes ``` ^(?=((?=((\2x?\|^)((?!(xx+)\5+$)))xx)x)(x))\6(?4)xx ``` [Try it online!](https://tio.run/##RU7LTsMwELz3K0xlNd48VKciHHDcpFK5cuJGWqugVrJk2mAHyciYXw/bgMRhVzujmZ3pj9ZU49snoVaQYC6vB0PoUiCU9XbztFnH2eliGXWSi3otIBB9QgSht/o8kHl3notIWiNdb/TAkiLJ3ceLG9Ci8qLMSzi@X0XNP8uRh3uqQFx/OUw82NbUKwiteS53EjffiTgjZErWfwTVtZwEeGUZBPSyxCeeapDfS2qXEKhbLKZeUy3sXIrfmlSLGKNSD49bpcY9aySbplv5tPnaA6Ib5n0GXZVRAPAePKTMpwDdHWtukRhHXpQV5z8 "Perl 5 – Try It Online") - Perl [Try it online!](https://tio.run/##XVBNa@NADL33V6jDgKXESeyQtISJ8aVdKJQednuL28H1TmqzzngYT2Gg29@eymFPe5DQk/SePlzrzvvStQ6khwLESsASnDfv2hvX143BZLWclVq3dR90M5xc1xtfYUWq@rkakxQStiMn9buZGmwwNoyo9Y@Hx3utKYWcWJKFFXS206MJKFzjzfKtbv4Ez0733akLIgWxWe82u5vb9W4rSF0dB4@yKzIl@@LI6iP@er57eCJFn9AdUfaHMfjeWI5okb8UhaisIG4eP964wuk0Sxc5TXwTXT/8NigWIuV2xfxm@LBh4u7XTDqwAPvsRV0BXCbbf1jafXGpczSfE48GvHzoVIemRelTHja9y9QBk5ik0hIRfE4rdmSadpj2UsCn5AomDNKqr6//foqkzq9YFnixah1n5d9XYnSNMc6p2s4ly8ZIkWYYZ0TVDZYbTpzP2SLfZtk3 "PHP – Try It Online") - PCRE Takes its input in unary, as a string of `x` characters whose length represents the number. Based on [Prime counting function](https://codegolf.stackexchange.com/questions/94348/prime-counting-function/222468#222468). ``` ^ # tail = N = input value (?= # Calculate π(N) = the number of primes <= N, by counting # from the largest to the smallest prime. ( # J = 0 (?= # \2 starts at zero, and on each subsequent iteration, contains the # difference N-P-(J-1) where P is the previously found prime, and J # is the running total of our prime count. ( ( \2 # Start from the previous value of \2. This # will make tail = P-1, where P is the # previously found prime. x? # Advance as little as necessary to make the # following match, and add this to \2, while # subtracting it from tail. \| # or ^ # Don't advance at all on the first iteration # (when \2 is is still unset), so as to assert # that N is not composite. ) ((?!(xx+)\5+$)) # Define and use subroutine (?4): Assert tail # is prime. Note that this needs to be inside # group \2 for it to work in PCRE1 and older # versions of PCRE2, which atomicize groups # that have nested backreferences. ) xx # Assert tail is prime by eliminating the # false positives 0, 1 ) x # J += 1; tail -= 1 )* # Iterate zero or more times, until there are no smaller primes # remaining. # At this point, head = π(N), and tail = N - π(N) (x) # \6 = tail = N - head = tool to make tail = head ) \6 # tail = π(N) (?4)xx # Assert tail is prime ``` Alternative ~~55~~ ~~54~~ 53 bytes: ``` ^(?=((?=((\2x?\|^)((?!(xx+)\5+$\|x?$))))x)(x))\6(?4) ``` [Try it online!](https://tio.run/##RU7LasMwELznK9QgYq0fWA51D5UVO5Bee8qtTkRaEhCoiSu5oKKov@4qaqELu@wMOzszHLWqp/cvhDVDTl3eDgrhkgXIm816u1752emiCTacsmbFwCF5CgjcoOV5RPP@PGcedYqbQcmRJEWSm89XMwaJyIsqr@D4cTtq/1kaeHjEAtjtlwmOB92pZgmuUy/VjodJd8zPEIrO8o/AsuHxIGxZBi5oSWITiyXw7xLrEhw2i0XMFWOFzBX7jYkl894L8fS8EWLak5aT2P3Spu11DwHdEWsz6OsMX22LIZSFlNgUoH8g7T1MEy2qmtIf "Perl 5 – Try It Online") - Perl [Try it online!](https://tio.run/##XVBNS8NAEL37K8ZlITNt2ialVco25KKCIB7UW6NLjFsTTDfLZoWA@tvrpHjyMMO8mXlvPlztjtvc1Q6khwzEQsAcnDfv2hvXlpXBaDGf5FrXZRt01R1c0xpfYEGqeFj0UQwR256T@t2MDTYYG3rU@ub27lpriiEllmRhBY1tdG8CCld5M38tq4/g2em2OTRBxCBWy81qc3G53KwFqbN951E2WaJkm@1ZvcfHp6vbe1L0Bc0eZbvrg2@N5Yhm6XOWicIK4ub@85UrnI6TeJbSyDeDa7s3g2ImYm5XzK@6TxtG7nbJpB0LsE@e1RnAabL9w9Jus1Odo@mUeDTg6UOHMlQ1Sh/zsPFdpgwYDVEsLRHB17hiQ6aqu3EvBXxKqmDEIK36@fn3UyR1fME8w5MVy2GSf78Qo3MchikV66n8HnLJ0jTQBIcJUXGB@YqOx2SWrpPkFw "PHP – Try It Online") - PCRE This eliminates the false negatives \$0\$ and \$1\$ in the definition of the primality subroutine instead of patching its ~~second and third~~ individual uses. # Regex (.NET), ~~70~~ ~~60~~ 58 bytes ``` ^(?=(\3?(?!(xx+)\2+$)(x))x)(?<-3>x){2,}(?<!\3\|^\4+(x+x)) ``` [Try it online!](https://tio.run/##RY9Ra4MwFIX/ipUL3pimaN1e6jILe94vUAti0xnIEokphjp/u9ONsbfznXM53NObUdihE0otYHlpxYfw9emkxYjnaLlgwbHK4gKLHXpPSXWkQNATEnuCxQvLXj2Zjvt51bsq@7pUTxQ9XfMlOu/DN/PZSyWuIcnhwZP8Zqxo2g5BBVIHIHV/d2SChoNiQ6@kC1mYyxtCc2jNXTumXHDcDiiHpkzqeS1A0LyU2tU/Tg6aKfHH6caUkmnrsIf3xrWdGDDyUQya/NoPMo1WOsE6M7h5fSvN/zlg2qzTldQiAD3P85Kw9DlJvgE "PowerShell – Try It Online") This uses the .NET feature of balanced groups to do the prime counting. Since .NET regex has no subroutines, this has ~~three~~ two copies of the primality test. ``` ^ # tail = N = input value # Calculate π(N) = the number of primes <= N, by counting # from the largest to the smallest prime. (?= # Atomic lookahead - lock in this match once it completes ( \3? # Advance as little as necessary to make the following # match, but don't advance at all on the first iteration # (when \3 is is still unset), so as to assert that N is # not composite. (?!(xx+)\2+$) # Assert tail is not composite (x) # Eliminate the false primality positive of 0, and advance # forward so that the next prime can be found (if we didn't # do this, the regex engine would exit the loop due to a # zero-width match); \3 = 1, to signal the first iteration # has been done, and push a capture onto the Group 3 stack. ) # Loop as many times as can be done until its stops # matching. x # Eliminate the false primality positive of 1 ) (?<-3>x){2,} # Pop all Group 3 captures off the stack, asserting that # the count is ≥ 2, and doing head += 1 for each one. Since # this isn't done atomically, we need to subsequently # verify that all captures were popped, due to backtracking # if the following assertion fails. (?<!\3\|^\4+(x+x)) # Assert that the Group 3 capture stack is empty, and that # head is not composite (and since it's already been # forced to be ≥ 2, this asserts it to be prime). ``` # Regex (Perl / Java / PCRE / .NET), 60 bytes ``` ^(?=((?=((\2x?\|^)(?!(xx+)\4+$))xx)x)(x))\5(?!(xx+)\6+$)xx ``` [Try it online!](https://tio.run/##RU5LT8MwDL7vV4QpWuM@1HSiHEizdtK4ctqNbtFAmxQpbCUpUlAIf71kAcHBlv097G84alVPrx8Ia4acurwcFMIlCytvNuvteuVnp4sm2HDKmhUDh@QpbOAGLc8jmvfnOfOoU9wMSo4kKZLcvD@bMVhEXlR5Bce3q6j9R2nA4R4LYNdbJnw86E41S3Cdeqp2PHS6Y36GUPwsfwEsGx4FYcoycMFLEptYLIF/lViX4LBZLGKuGCtkrthPTCyZ916Ih8eNENOetJzE6pc2bT/3QNobYm0G/W2GAawFCymxKUBf/1F3gbJ2mmhR1ZR@Aw "Perl 5 – Try It Online") - Perl [Try it online!](https://tio.run/##bVJhT9swEP3OrziiTbXTYlI09mEmqrZpk5DGNsHHtkhu4rQGx8lshxoYv707pxkbEpEi@@6d3/k93424E0c35e1O1W1jPdxgzFTDUg7/Zzqv9Ks5K9cyIHLQdiutCii0cA4uhDLwCEPOeeFxuWtUCTUi5MpbZdYg7NrNlxT8xjZbB19CIVuvGjx5APBVaQlVbuS235KEFU0pGeIJ5Z@6qpJWlpdSlNLCqi97mSR/Tw5hRSkf@rqJ59tN5CfE5SvUIMpvykhC6WFuOq2pqohj8lcntCPJcZqmCaWPL0v3DIT4VwkekcE/MyDBMTKssO6Wu3E@WphRXD1/2ueefgrvpTVg82GHaus2NnCUoxurptFSGHjIK2SUHK4KYQxKV6btPOQQ1Q45cnXvvKyZMpTDoLMvYxvhvsvg8Zq9xQCDIRrvjhz7IoMVg8QBny9BIxyrmGu18iQ5wkfAeg8mQ@TceBwDy1phncSA6Hm2pBMw01dBpqVZ@83ZCcwgVsIHXKZLZCw2ws6XYdDTR2a65PDRWnHvWKW0JmEyCqPeFICqsVEbXiM3GQdzlpspLuMxCrwQvtigQzWyWVbvI9JPrsEB/4zk@4lhWytaMrQomvb@R3UpzFpip2xiKI1KKyA1tjclehff9oEOJjfo2NYqL0l8VMofcm@7@D7/4BY99BVJ3roELaH8KX4Hcap212SWk/5fnIR09vuaktkhCWFMF@/GbygNgQaakpBSujh9ht4jFMIuTtUuO5qeZtkf "Java (JDK) – Try It Online") - Java* [Try it online!](https://tio.run/##XVBNa@NADL33V6jDgKXESeyQtISJ8WW7UCh72O2tbgfXndRmnfEwnsJAt789lUPZQw8Skp7e04dr3WlfutaB9FCAWAlYgvPmVXvj@roxmKyWs1Lrtu6Dboaj63rjK6xIVb9XY5JCwnbgon41U4MNxoYRtf55e3ejNaWQE0uysILOdno0AYVrvFk@183f4Nnpvjt2QaQgNuvdZnd1vd5tBamLw@BRdkWmZF8cWH3EP/c/bn@RonfoDij7hzH43liOaJE/FoWorCBuHt@eGeFymqWLnCa@ia4fXgyKhUi5XTG/Gd5smLj7NZMeWIB99qguAM6T7Vcu7b444xzN58SjAc8fOtahaVH6lIdN7zJ1wCQmqbREBO/Tih2Zph2mvRTwKbmCKQdp1cfHt58iqdMTlgWerVrHWfnvibC8xBjnVG3mkihGijTDOCOqtv@hK4ZiPJ2yRb7Nsk8 "PHP – Try It Online") - PCRE [Try it online!](https://tio.run/##RY9Ra4NAEIT/ipUFb7UXNDR9iBwG@txfoAbEbOrB9U7OCx6x/narKW0f5uGbWYbZ3oxkh46UWsCK0tIH@fp41DSyU7ScWSHYQ9Xex8XXGVnxxLxPsHpJANF79BgzHyNWh7/odY28X6LTc/hmPnup6BJiDneR5ldjqWk7BiqQOgCp@5vDCRoBig@9ki7kYS6vDJpda27aceWC/XaQCGjKtJ7XAgZalFK7@uHkoLmiX842ThKctg67e29c29HAIh/FoPHHvuM0WumId2Zw8zory/854NqszyupKQA9z/OS8uyQpt8 "PowerShell – Try It Online") - .NET This is a straight port of the Perl/PCRE version, to regex engines that lack subroutine calls but support nested backreferences. The subroutine call has been replaced with a copy of the routine. # Regex (Perl / PCRE / Python[`regex`](https://github.com/mrabarnett/mrab-regex)), 61 bytes ``` ^(?=((?=((\6x?\|^)((?!(xx+)\5+$)))xx)(?=(\2))x)(x))\7(?4)xx ``` [Try it online!](https://tio.run/##RU7LTsMwELz3K0xlNd48VKciIOG4SaVy7Ykbaa2CWsmSaUMcJCNjfj1sAhKHXe3M7uxMe@pMMbx9EtoJ4s319WgIXQqEstxunjbrMDtfO0at5KJcC/BEnxGBbzt96cm8ucxFILWRtjW6Z1EWpfbjxfYoUWmWpzmc3sej6p/lyMMDVSDGXxYdj11tyhX42jzne4md70WYETI56z@C6lJOBzglCXjUsshFjmqQ30vaLcFTu1hMuaZYmDkXvzGpFiEEpR53W6WGA6skm6q5c3H1dQBEN8y5BJoioQDgHIz7ZoUjxMzFAM09q25xMQw8ywvOfwA "Perl 5 – Try It Online") - Perl [Try it online!](https://tio.run/##XVBNS8NAEL37K8ZlITNt2ialVco25KKCIB7UW6NLjFsTTDfLZoWA@tvrpHjyMMPMvHlvPlztjtvc1Q6khwzEQsAcnDfv2hvXlpXBaDGf5FrXZRt01R1c0xpfYEGqeFj0UQwR256L@t2MDTYYG3rU@ub27lpriiEllmRhBY1tdG8CCld5M38tq4/g2em2OTRBxCBWy81qc3G53KwFqbN951E2WaJkm@1ZvcfHp6vbe1L0Bc0eZbvrg2@N5Yhm6XOWicIK4ub@85URLsdJPEtp5JvBtd2bQTETMbcr5lfdpw0jd7tk0o4F2CfP6gzgNNn@5dJusxPO0XRKPBrw9KFDGaoapY952PguUwaMhiiWlojga1yxIVPV3biXAj4lVTDmIK36@fn3UyR1fME8w5MVF8Mk/34hzs5xGKZUrKeSZYeBRrxYckgTHCZExSXmKwaOx2SWrpPkFw "PHP – Try It Online") - PCRE [Try it online!](https://tio.run/##NY/RboMwDEXf@Qov2kMMASXt1kmwiA8BKlVrKKmygJJMSqX9OyNse7Bk3@N7LS@PMM32uOrPZXYB/MMzp24qsrufbQNOOkLIeqatpHv1p5i332fcpicaY4H9a/GMiDFi4v1hazGnMUfs32j7soF1S@hEXYqhAS15Ns4ODGibjlU@XLWtMzDSVH4xOlBSEsxAj2CUpQbfDzWYTgzSdHzIIJltMruLvSmqbaAJIPvtxICFwC0vBeyPVF5d3MdEHQMSSW53mKiuYXHJNZovP0mBuy5F8yf74KhFpuxVEsL@l1ZeCs75Dw "Python 3 – Try It Online") - Python `import regex`* This is a port of the Perl/PCRE version. `\2` is copied into `\6` using the lookahead `(?=(\2))`, since Python (even with `import regex`) lacks nested backreferences. # Regex (PCRE / Ruby), 62 bytes ``` ^(?=((?=((\6x?\|^)((?!(xx+)\5+$)))xx)(?=(\2))x)(x))\7\g<4>xx ``` [Try it online!](https://tio.run/##XVBNT8MwDL3zK0wUqfHWbe20gaas7AJISIgDcCMQlZKtFV0apUGKBPvtw504cbDlZ/s9f7jaHdcbVzvgHgpgMwZTcN7stDeuLSsjktl0tNG6Ltugq27vmtZ4JRRK9TjrkxQSsi0l9c4MDTYYG3qh9e3d/Y3WmEKOJEnCEhrb6N4EwVzlzfS9rD6DJ6fbZt8ElgJbzFeL1cXlfLVkKM@2nRe8KTLJ22JL6r14er6@e0CJ39BsBW9f@uBbYynCSf5aFExZhtTcf71ThdJplk5yHPgmurb7MIJNWErtkvhV92XDwF3PifRCAuSzV3kGcJps/zC36@JUp2g8RhoN4vShfRmqWnCf0rDhXaYMIolJyi0iwvewYoOmqrthLwl0Si5hwMCtPBz@/VSgPL6JTSFOpi7iaPPzhoTORYxjVMsxJ9kYcairOYU4EnGEqC7Vbr24ivF4zCb5Mst@AQ "PHP – Try It Online") - PCRE [Try it online!](https://tio.run/##PY5Ba8MwDIXv@xVqGNRKiXHCuh1crxS66w5jt7g1G3VTg3GD41IPxv56ZoetBxm/p/dJ8pfPr9GDgDfd6dhTp6@w3bxvqNcfBw5GMA7Xk7EarOh0GO4AzBFsW9U7IQrpCp4atmWUVs2Og3aHlEgOHXprAplXc/xDqNWuCyeCqyYxbeITdkOOZw8OjINs0nBWhtQMKc3Bm0y5aRYpYlE6BPEDnmfDzPKd/SUM07x8d520Ny6A@1@R31xKvbxulRr3ZC3IVPIxluvvPSY1IzEuUC4X94gYI@a@bNIXSxJLRPkku9XDc4zjyKp6ydgv "Ruby – Try It Online") - Ruby* This is a straight port of the Python[`regex`](https://github.com/mrabarnett/mrab-regex) version, to Ruby's subroutine call syntax. # Regex (Perl / Java / PCRE / Python[`regex`](https://github.com/mrabarnett/mrab-regex) / Ruby / .NET), 68 bytes ``` ^(?=((?=((\5x?\|^)(?!(xx+)\4+$))xx)(?=(\2))x)(x))\6(?!(xx+)\7+$)xx ``` [Try it online!](https://tio.run/##RU7LTsMwELz3K0xlNd48FKeiIOG4SaVy5cQNt1ZBrWTJtMEOkpExvx6cgOCwq9nZ2Z3pjkavhtcPhA1DXl9eDhrhksWR19vN42YdZqeLIdhyyuo1A4/UKU7gO6POPZqL85wF1GpuO616khRJbt@fbR9PZF5UeQXHt1HU/LM08nCHJbDxl42OB9Pqegm@1U/VjsdOdyzMEJqc1S@BVc0nQURZBj7eksQlDivgXyU2JXhsF4sp1xQrZq7YT0ysWAhByvuHrZTDnjScTCVWLm0@90CaK@JcBuI6wwDOwbgVywghJS4FEDd/ktsocW4YaFFRSr8B "Perl 5 – Try It Online") - Perl [Try it online!](https://tio.run/##bVLvT9swEP3OX3FEm2qnxaRoP6SZqNqmIU0a2wQf2yK5idMaHCezHWpg/O3dOc3YkIgU2Xf3/M7v@a7FrTi6Lm92qm4b6@EaY6YalnL4P9N5pV/MWbmWASsHbbfSqoBCC@fgXCgDDzDknBcel9tGlVBjhVx6q8wahF27@ZKC39hm6@BLKGTrVYMnDwDOlJZQ5UZu@y1JWNGUkmE9ofxTV1XSyvJCilJaWPWw50ny9@QQVpTyoa@beL7dRH5CXL5CDaL8powklB7mptOaqoo4Jn91QjuSHKdpmlD68By6ZyDEv0jwgAz@iQEJjpFhhbgb7sb5aGFGcfX8cZ97/Cm8l9aAzYcdqq3b2MBRjm6smkZLYeA@r5BRcrgshDEoXZm285BDVDvkyOWd87JmylAOg84exjbCfZfB4zV7iwEGQzTeHTn2IIOIQeJQny9BYzmimGu18iQ5wkdAvAeTYeWr8TgGlrXCOokB0fNsSSdgpi8WmZZm7TenJzCDiIQPuEyXyFhshJ0vw6Cnj8x0yeGjteLOsUppTcJkFEa9KQBVY6M2vEZuMg7mNDdTXMZjFHgufLFBh2pks6zeR6SfXIMD/hnJ9xPDtla0ZGhRNO3dj@pCmLXETtnEUBqVVkBqbG9K9C6@7T0dTG7Qsa1VXpL4qJTf59528X3@lVv00Fckee0StITyx/gdxKnaXZFZTvp/8Taks99XlMwOSQhjungzfkVpCDRWFye4pSkJKaWLd0@Q9wgJYRena5cdTbMs@wM "Java (JDK) – Try It Online") - Java [Try it online!](https://tio.run/##XVBNa@MwEL33V0yFwDOJk9ghbQmK8WW7UCg97PYWt8J1ldqsIwtZBUG3vz0dh7KHPcwwH@@9@XCtO@1K1zqQHgoQKwFLcN68aW9cXzcGk9VyVmrd1n3QzXB0XW98hRWp6tdqTFJI2A5c1G9mAthgbBhR659397daUwo5sSQLK@hsp0cTULjGm@VL3fwJnp3uu2MXRApis95uttc36@2VIHVxGDzKrsiU7IsDq4/4@/HH3QMp@oDugLLfj8H3xnJEi/ypKERlBTF4fH/hDpfTLF3kNPFNdP3walAsRMpwxfxmeLdh4u7WTNqzAPvsSV0AnCfb71zaXXHuczSfE48GPH/oWIemRelTHja9y9QBk5ik0hIRfEwrdmSadpj2UsCn5AqmHKRVn5///RRJnZ6xLPBs1VWclX@fCctLjHFO1WYuiWKkqVutOaQZxhlRdf0PcsOQGE@nbJFnWfYF "PHP – Try It Online") - PCRE [Try it online!](https://tio.run/##PY/daoQwEIXvfYpp6EVGoyTbdgva4IOoC0s3rinZKEkKWei7W2N/LgYO851zhlnuYZrt06pvy@wC@LtnTl1VZB9@tg046Qgh64m2ku7Tv8S8/TohbR9ojAX2z8UjYoyYaH/YJOY05oj98d/yulliXLeiTtSlGBrQkmfj7MCAtulm5cNF2zoDI03lF6MDJSXBDPQIRllq8O1Qg@nEIE3HhwxS2KawO9urotoGmgCyHyUGLARufalg/6fy6uzeJ@oYkEhyu8NEdQ2LS6nRfPpJCtz3UjS/ax8ctciUvUhC2J9p5aXgnH8D "Python 3 – Try It Online") - Python `import regex` [Try it online!](https://tio.run/##PY7BasMwDIbvewo1DGqlxDih6w6eCYXuusPYLWnNSt3UYNzguNSDsVfP7LDlICH9@j9J7nb8Gh0IeFedCj216g677ceWOvV54qAF43C/aKPAiE754QFAn8E0RbkXImttxuPANIzSotpzUPYUHVGhQ2@0J8tiiX8INcp2/kLwpYpME/mIzcj56sCCtpBE6q9Sk5Ihpck4t9E37SJZyHKLIH7A8SToRfqzv/lh2pf@LmPvtPVg/0@knELK17edlOOB1IJM0T6FvP4@IKkXJIQVtuvVI2IImKZtFUvMScgR281seY6WEMaRFSVj7Bc "Ruby – Try It Online") - Ruby [Try it online!](https://tio.run/##RZDdaoQwEIVfxcqAGW2WuPQHVoILve4TqAviZmsgTSRmMaz12W3c0vZiYM6Zj8NhBjMJO/ZCqRUsr6z4EL45HLSYyDFZT6Tk5D71s0/LrxOS8oF4n2H9lAGi97hd631YMSU@Raxf/pDXgHi/JsfH@M18DlKJc4wF3DgrLsaKtusJqEjqCKQerg5naDkoOg5KupjGhbwQaHeduWpHlYv2G5BxaCvWLCGAgOaV1K65OwVoqsSvzjedZThvGXb33rquFyNJfJKCxh/7hvNkpRO0N6NbQq28@NcR1SY8QUktItDLsqyM5oyxbw "PowerShell – Try It Online") - .NET To be portable to all 6 regex engines, this uses neither nested backreferences nor subroutine calls. [Answer] # [Python 3](https://docs.python.org/3/), ~~104~~ ~~97~~ 93 bytes ``` p=lambda m:(m>1)all(m%x for x in range(2,m)) f=lambda n:p(n)p(len([filter(p,range(n+1))])) ``` Returns `0`/`1`, at most 4 bytes longer if it has to be `True`/`False`. [Try it online!](https://tio.run/##PYzBCsIwEETv/YqlIOy2ezDW0jagPyIeIjZaSLYh5lC/PgZEBwaGx8yEd3qu0uUcTs74292A1@jPihrjHPrdBnaNsMEiEI08ZjywJ6rsry06oFAT0M2Cl8YuLs0RA3/L0iqiK1H@n5Q9dAxHhp5hYFCquABV8rCfGMa@kGlSpCsoCnGRhK8UcaO21jWDLYnyBw "Python 3 – Try It Online") [Answer] # [Python 2](https://docs.python.org/2/), 79 bytes ``` n=input() s={2};p=i=1 while i<n: p=i;i+=1 if pp%i:s\|={i} print{n,len(s)}<=s ``` [Try it online!](https://tio.run/##DchBCoAgEAXQvadwE2S10U1QzXEMP8g0pBFhnt1avidPDge71pjAcuXeqETF1VUIZNUdEL3GxovSMhBWjP9q7L@kw5JeKqhKTnAuPEXPfTJ1o9SanT8 "Python 2 – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes ``` ÆCÆPaÆP ``` [Try it online!](https://tio.run/##y0rNyan8//9wm/PhtoBEIP7//7@lpSEA "Jelly – Try It Online") `ÆC` counts the number of primes less than or equal to the input (so, if the input is the nth prime, it returns n). Then `ÆP` tests this index for primality. Finally, `a` does a logical AND between this result and `ÆP` (primality test) of the original input. [Answer] # [Haskell](https://www.haskell.org/), 62 bytes ``` p x=2==sum[1\|0<-mod x<$>[1..x]] f x=p$sum[1\|y<-[1..x],p y,p x] ``` [Try it online!](https://tio.run/##ZcmxCoMwFEbh3af4h4xX8WolDSR9kZAhYKVSo6G2EMF3j4Jjh7Oc7@XX93Oaco5IpjFm/QXLe63LsPRIWjwsV1VyrhhOj@LiTZfXpojtLLkc/DjDoF8KIH7G@QuB4CMG2IZuJIlbunfs/rmljpiJJclakVLs8gE "Haskell – Try It Online") Usage: `f 991` yields `True`. [Answer] # [Husk](https://github.com/barbuz/Husk), 2 bytes ``` ṗṗ ``` [Try it online!](https://tio.run/##yygtzv7//@HO6UD0//9/cwA "Husk – Try It Online") One of the cases when the behaviours of functions returning non booleans is really helpful. user's solution. # [Husk](https://github.com/barbuz/Husk), 4 bytes ``` ṗ£İp ``` [Try it online!](https://tio.run/##yygtzv7//@HO6YcWH9lQ8P//f1MA "Husk – Try It Online") or [Verify all test cases](https://tio.run/##yygtzv6f@6ip8f/DndMPLT6yoeD////RRjrGOiY6pjrmOoaGOobGOobmOuYGljoWpoY6lpaGsQA "Husk – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes ``` ÝØ<Øså ``` [Try it online!](https://tio.run/##MzBNTDJM/f//8NzDM2wOzyg@vPT/f0NDAA "05AB1E – Try It Online") ### Explanation ``` ÝØ<Øså Ý # Push range from 0 to input Ø # Push nth prime number (vectorized over the array) < # Decrement each element by one (vectorized) Ø # Push nth prime number again s # swap top items of stack (gets input) å # Is the input in the list? ``` [Answer] # [Pyth](https://github.com/isaacg1/pyth), 12 bytes ``` &P_QP_smP_dS ``` [Try it online!](https://tio.run/##K6gsyfj/Xy0gPjAgvjg3ID4l@P9/Q0MA "Pyth – Try It Online") ### Explanation ``` &P_QP_smP_dS Implicit input mP_dS Primality of all numbers from 1 to N s Sum of terms (equal to number of primes ≤ N) P_ Are both that number &P_Q and N prime? ``` [Answer] # Mathematica, ~~35~~ 29 bytes ``` P=Prime;!P@P@Range@#~FreeQ~#& ``` -6 bytes from @MartinEnder [Answer] ## Pyke, 8 bytes ``` sI~p>@hs ``` [Try it here!](http://pyke.catbus.co.uk/?code=sI%7Ep%3E%40hs&input=5&warnings=0) ``` s - is_prime(input) I~p>@hs - if ^: ~p> - first_n_primes(input) @ - ^.index(input) h - ^+1 s - is_prime(^) ``` [Answer] # [Python 2](https://docs.python.org/2/), 89 bytes ``` def a(n): r=[2];x=2 while x<n:x+=1;r+=[x]all(x%i for i in r) return{n,len(r)}<=set(r) ``` [Try it online!](https://tio.run/##TY2xCsIwEED3fMUtQmIdNKBD2/uSkCHg1R6EazkjRsRvj3Vze8N7vPVV5kV8a1eaIFlxvQHF4ONQ0Rt4zpwJ6ih97fA0aIehxn3K2dYdw7QoMLCAuq2i8lB5yyGTWHWfEe9UNmirshQI/3qSG9nL@eiAf1d20bQv "Python 2 – Try It Online") Constructs `r`, the list of primes <= n; if n is prime, then `n` is the `len(r)`'th prime. So n is a super prime iff n in r and len(r) in r. [Answer] # [Factor](https://factorcode.org/) + `math.primes`, ~~51~~ ~~49~~ ~~36~~ 32 bytes Saved 13 bytes thanks to @Bubbler! Saved 4 bytes thanks to @chunes! ``` [ dup nprimes index ?1+ prime? ] ``` [Try it online!](https://tio.run/##NYyxCsIwFEV3v@LuQvBZS60OHcXFRZzEIaSvWkxfY5KCIn57lKrL4XK4nEab2Pt02G93mxWu7IUtnOcYH863EhH4NrAYDrC90Tag0/EyQn0OHX@F8lrO/90MYmLbS8B68gRhjgwL5ChABMpABYpZiWVOKEvCKx1RDw7y67VS8x0VTTGKCqfUaQeV3g "Factor – Try It Online") ``` [ dup nprimes index ?1+ prime? ] dup nprimes ! First n primes (generates extra primes) index ! Find the index of the input in that ! when the index is not found, an f is outputted ! If the index exists, ?1+ ! If it's a number, increment ! If it's f, output 0 (which is not prime) prime? ! Is that prime? ``` [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal) `g`, 4 bytes ``` ¡†"æ ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyJBZyIsIiIsIsKh4oCgXCLDpiIsIiIsIjJcbjNcbjRcbjVcbjdcbjExXG4xM1xuMTdcbjcwOVxuODUxXG45OTEiXQ==) - test cases only This is the same as the 5 byte answer below except the minimum is taken by the `g` flag rather than a `g` element. # [Vyxal](https://github.com/Vyxal/Vyxal), 5 bytes ``` ¡†"æg ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCLKgChuzrsiLCLCoeKAoFwiw6ZnIiwiO+KAoFtuLF0pIiwiMTUwMCJd) [Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwiwqHigKBcIsOmZyIsIiIsIjJcbjNcbjRcbjVcbjdcbjExXG4xM1xuMTdcbjcwOVxuODUxXG45OTEiXQ==) - test cases only This makes use of [Prime counting function](https://codegolf.stackexchange.com/questions/94348/prime-counting-function/250044#250044), based on [Dennis's 05AB1E solution](https://codegolf.stackexchange.com/a/94364/17216) to that challenge. This is actually much faster than the other two 5 byte solutions presented below it. ``` ¡ # Factorial † # Number of distinct prime factors – when applied to the factorial, this # gives the index of the greatest prime ≤ the input number (1-indexed). " # Wrap the top two items (the input number, and the above result) in a list. æ # Is the number prime? (Vectorized) g # Minimum - effectively applies a boolean AND to the list ``` --- Alternative 5 bytes: ``` Þpḟ›æ ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCLKgChuzrsiLCLDnnDhuJ/igLrDpiIsIjvigKBbbixdKSIsIjEwMDAiXQ==) [Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwiw55w4bif4oC6w6YiLCIiLCIyXG4zXG40XG41XG43XG4xMVxuMTNcbjE3XG43MDlcbjg1MVxuOTkxIl0=) - test cases only ``` Þp # An infinite list of primes ḟ # Index of input number in that list (0-indexed; -1 if not found) › # Add 1 æ # Is the number prime? ``` --- Another alternative 5 bytes: ``` Þp‹ǎc ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCLKgChuzrsiLCLDnnDigLnHjmMiLCI74oCgW24sXSkiLCIxMDAwIl0=) [Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwiw55w4oC5x45jIiwiIiwiMlxuM1xuNFxuNVxuN1xuMTFcbjEzXG4xN1xuNzA5XG44NTFcbjk5MSJd) - test cases only Port of [Datboi's 05AB1E solution](https://codegolf.stackexchange.com/a/130398/17216). This is much slower than the primary 5 byte solution above, but much faster than its 05AB1E counterpart. ``` Þp # An infinite list of primes ‹ # Subtract 1 from every item on the list ǎ # Nth prime - vectorized to the entire list c # Contains - Is the input number a member of that list? ``` [Answer] # [Thunno](https://github.com/Thunno/Thunno) `D`, \$ 8 \log\_{256}(96) \approx \$ 6.58 bytes ``` FAFLZPNP ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_abSSi1LsgqWlJWm6FivcHN18ogL8AiBcqOiCRYaGEBYA) Port of Deadcode's Vyxal answer. It's all uppercase letters! #### Explanation ``` FAFLZPNP # Implicit input F # Factorial AF # Unique prime factors L # Length ZP # Pair N # Is prime P # Product # Implicit output ``` [Answer] # [Raku](https://raku.org/), ~~46~~ 35 bytes ~~`{$/=&is-prime;all($_∈,$/)([grep $/,1..$_])}`~~ ``` grep {.is-prime&&is-prime ++$},^∞ ``` [Try it online!](https://tio.run/##K0gtyjH7n1up4FCsYPs/vSi1QKFaL7NYt6AoMzdVTQ3GUtDWVqnViXvUMe@/tUJxIkh5dJyhaex/AA "Perl 6 – Try It Online") Six years of golfing experience let me cut down on this solution considerably. [Answer] # [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 33 bytes ``` ~µ:\|\|\_x0]{p=p-µq\|~q=a\|_xµp]q=q+1 ``` ## Explanation ``` ~ \| IF .... THEN (do nothing) : the number 'a' (read from cmd line) µ \| is Prime \_x0 ELSE (non-primes) quit, printing 0 ] END IF { DO In this next bit, q is raised by 1 every loop, and tested for primality. p keeps track of how may primes we've seen (but does so negatively) µq\| test q for primality (-1 if so, 0 if not) p=p- and subtract that result from p (at the start of QBIC: q = 1, p = 0) ~q=a\| IF q == a _xµp QUIT, and print the prime-test over p (note that -3 is as prime as 3 is) ] END IF q=q+1 Reaise q and run again. ``` [Answer] ## Haskell, 121 bytes ``` f=filter p x=2==(length$f(\a->mod(x)a==0)[1..x]) s=map(\(_,x)->x)$f(\(x,_)->p x)$zip[1..]$f(p)[2..] r x=x`elem`(take x s) ``` [Answer] # [Positron](https://github.com/alexander-liao/positron), 148 bytes ``` x=#(input@@)a=function{p=1;k=$1==2;f=2;while(f<$1)do{p=p$1%f;k=1;f=f+1};return pk}r=1;i=2;while(i<x)do{if(a@i)then{r=r+1}i=i+1}print@((a@xa@r)>0) ``` [Try it online!](https://tio.run/##PYvBDsIgEER/xURMoF5Ej3QNv0IU0k3NQlaIJE2/HdeLh5nDvHklv7FypjE6HDVSadV7EyA1elTMtBWwbgVlAa4uST4LvqJOs7LmmYWWSdlTkosVnM52dxxrYzqUad1ZVvxLOPefg0kHj6YukTYGFgUBpQsjVa8F9il4NveLGeP2BQ "Positron – Try It Online") [Answer] # [Pari/GP](http://pari.math.u-bordeaux.fr/), 31 bytes ``` n->(p=isprime)(n)p(primepi(n)) ``` [Try it online!](https://tio.run/##K0gsytRNL/ifZvs/T9dOo8A2s7igKDM3VVMjT1OrQAPMLsgEcjT/p@UXaeQp2CoY6igYGhjoKADl8kqAIkoKunZAIg2kSPM/AA "Pari/GP – Try It Online") [Answer] # Matlab, ~~36~~ 34 bytes Saved 2 bytes thanks to Tom Carpenter. A very naive implementation using built-in functions: ``` isprime(x)&isprime(nzz(primes(x))) ``` [Answer] # Julia 0.6, 61 bytes return 1 if x is a super-prime, 0 otherwise. without using an isprime-kind function. ``` x->a=[0,1];for i=3:x push!(a,0∉i%(2:i-1))end;a[sum(a)]&a[x] ``` [Answer] # [Japt](https://github.com/ETHproductions/japt), 11 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) ``` ÒÈj}jU bU)j ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=0shqfWpVIGJVKWo&input=OTkx) [Answer] # [Pyth](https://github.com/isaacg1/pyth), 9 bytes ``` P_hx.fP_Z ``` [Test suite](http://pythtemp.herokuapp.com/?code=P_hx.fP_Z&test_suite=1&test_suite_input=2%0A3%0A4%0A5%0A7%0A11%0A13%0A17%0A709%0A851%0A991&debug=0) Uses a fairly different approach to the existing Pyth solution. Returns `True` for super-primes, `False` for non-super-primes, and `[]` (falsy) for composite numbers. [Answer] # [Ruby](https://www.ruby-lang.org/), 72 bytes Tired of all the extremely obscure golfing languages in this thread? Here's the practical language solution you're looking for! Let me know if you see a way to shave off a few bytes. ``` require'prime';n=gets.to_i;p n.prime?&&(Prime.take(n).index(n)+1).prime? ``` [Try it online!](https://tio.run/##KypNqvz/vyi1sDSzKFW9oCgzN1XdOs82PbWkWK8kPz7TukAhTw8sbK@mphEAYuiVJGanauRp6mXmpaRWABnahppQJf//W1oaAgA "Ruby – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes ``` .Ø>‚pß ``` [Try it online!](https://tio.run/##yy9OTMpM/W9QbOfm4vJf7/AMu0cNswoOz/@feWifoUOmkpJOrYv9oT21drX/DU0NDAA "05AB1E – Try It Online") - 05AB1E [Try it online!](https://tio.run/##yy9OTMpM/X9uq8t/vcMz7B41zCo4PP///2gjHQVjHQUTHQVTHQVzHUNDHUNjHUNzHXMDSx0LU0MdS0vDWAA "05AB1E – Try It Online") - 05AB1E - test cases only [Try it online!](https://tio.run/##MzBNTDJM/X9uq8t/vcMz7B41zCo4PP///2gjHQVjHQUTHQVTHQVzHUNDHUNjHUNzHXMDSx0LU0MdS0vDWAA "05AB1E (legacy) – Try It Online") - 05AB1E (legacy) - test cases only Equal in length to [Datboi's solution](https://codegolf.stackexchange.com/a/130398/17216), but much faster on numbers that are not super-prime. ``` .Ø # Get 0-indexed number of the greatest prime ≤ input number > # Add 1 ‚ # Wrap the top two items (the input number, and the above result) in a list p # Is the number prime? (Vectorized) ß # Minimum - effectively applies a boolean AND to the list ``` --- Alternative 6 bytes: ``` !fg‚pß ``` [Try it online!](https://tio.run/##yy9OTMpM/W9QbOfm4vJfMS39UcOsgsPz/2ce2mfokKmkpFPrYn9oT61d7X9DAwMDAA "05AB1E – Try It Online") [Try it online!](https://tio.run/##yy9OTMpM/X9uq8t/xbT0Rw2zCg7P//8/2khHwVhHwURHwVRHwVzH0FDH0FjH0FzH3MBSx8LUUMfS0jAWAA "05AB1E – Try It Online") - test cases only This makes use of [Dennis's Prime counting function solution](https://codegolf.stackexchange.com/a/94364/17216), which is equal in length to (but slower than) the ones using built-in prime-counting functions. [Answer] # [C89 (clang)](http://clang.llvm.org/), 92 bytes ``` #define s for(i=e;--i&&e%i;)p+=i <3 p,r,i;m(e){s;for(p=r=i==e%2;--e;)s;e=p+1;s;return r<i<r;} ``` (added whitespace for readability) ### Some alternatives: * `i==e%2` \$\equiv\$ `i==1&e` * `r<i<r` \$\equiv\$ `1<i<r` \$\equiv\$ `i<2&r` \$\equiv\$ `i/2<r` \$\equiv\$ `i<r+r` \$\equiv\$ `i<2*r` [Try it online!](https://tio.run/##FY3NasMwEITP1lMsCQ4Stkt@Li0r9V2MtEoX7LWQnF5CXr2qchuG75vxk19mudd6DBRZCArELWt2hNPEpxP1jCYNju1NpTGPjKsm8yz4ppLLjp2j/tpgQlOQXBouWDDT/sgC2bLN@KpHFr88AoEte@Dt4@dbKZZdrTOL/t04GPVUXWtAUKmubYMWcHBBELBwPZ8RhkGM6jqOoFct5p27lJsT9aEPcBhBDKpX/fNxme@lTu3K@c@vfw "C (clang) – Try It Online") ]
[Question] [ ## Challenge : \$\pi\$ is supposed to be infinite. That means every number is contained inside the decimal part of \$\pi\$. Your task will be to take a positive integer on input and return the position of this number in \$\pi\$ digits on output. For example, if the input is `59`, we'll return `4` Here is why : we will look for the number `59` in the digits of \$\pi\$ ``` 3.14159265... ^^ ``` The value starts at the 4th digit, so the output will be `4`. Some other examples : ``` input : 1 output : 1 input : 65 output : 7 input : 93993 output : 42 input : 3 output : 9 ``` ## Rules : * You don't have to handle digits that doesn't exist within the first 200 digits * Standard loopholes are, as always, forbidden. * This is [codegolf](/questions/tagged/codegolf "show questions tagged 'codegolf'"), so the fewer bytes wins. [Answer] # Python 2, ~~69~~ ~~75~~ ~~71~~ 67 bytes Saved 4 bytes due to [caird coinheringaahing](https://codegolf.stackexchange.com/posts/comments/390415?noredirect=1). ``` x=p=1333 while~-p:x=p/2x/p+210200;p-=2 print`x`.find(input(),1) ``` Not finding `3` at position zero cost ~~6~~ 2 bytes. Input is given as a string. [Try it online!](https://tio.run/##K6gsycjPM/r/v8K2wNbQ2NiYqzwjMye1TrfACiiib6RVoV@gbaRlaKClZWRgYF2ga2vEVVCUmVeSUJGgl5aZl6KRmVdQWqKhqWOo@f@/kqmlEgA "Python 2 – Try It Online") --- Unbounded Version** ## Python 2, 224 bytes ``` def g(): q,r,t,i,j=1,0,1,0,1 while True: i+=1;j+=2;q,r,t=qi,(2q+r)j,tj;n=(q+r)/t if nt>4q+r-t:yield n;q,r=10q,10(r-nt) a=input() l=len(`a`) s=z=10l;i=1-l p=g().next;p() while s!=a:s=(s10+p())%z;i+=1 print i ``` Using an unbounded spigot based on the same formula used above. [Try it online!](https://tio.run/##Jc5LjsIwDAbgfU4RFiMlqTs0ZVaNzCk4AJUI4CoKaWrE4/KdBBa2ZPuz9KcXX2@xX9eTP8uL0oOQM2RgIJjQQgefEvJxpeDlId99EZIatG5qsHcfjLMhUL2Zm6zNBGwmF1HVactVn2U0vP@r95aHF/lwkrG@ou3MDKWp3BaixYgU052VFgGDj@o4HrVY8F2hCY7QtkEkLEF/o3@yS0V@oy0bHIcF1WJs15S1/nm7GlOkTJElravtd/8 "Python 2 – Try It Online") --- Faster Version ``` from gmpy2 import mpz def g(): # Ramanujan 39, multi-digit q, r, s ,t = mpz(0), mpz(3528), mpz(1), mpz(0) i = 1 z = mpz(10)*3511 while True: n = (q+r)/(s+t) if n == (22583iq+r)/(22583is+t): for d in digits(n, i>597 and 3511 or 1): yield d q, r = z(q-ns), z(r-nt) u, v, x = mpz(1), mpz(0), mpz(1) for k in range(596): c, d, f = i(i(i32-48)+22)-3, 21460i-20337, -iii24893568 u, v, x = uc, (ud+v)f, xf i += 1 q, r, s, t = qu, qv+rx, su, sv+tx def digits(x, n): o = [] for k in range(n): x, r = divmod(x, 10) o.append(r) return reversed(o) a=input() l=len(`a`) s=z=10*l;i=1-l p=g().next;p() while s!=a:s=(s10+p())%z;i+=1 print i ``` A much faster unbounded spigot, based on [Ramanujan #39](https://books.google.fr/books?id=oSioAM4wORMC&pg=PA38&hl=en#v=onepage&q&f=false). [Try it online!](https://tio.run/##ZVLRjpswEHz3V2xVVbKNuWITciQR/Yiqb1WlQ7XJuQVDjEmT/Hy6BpI@VCB5dzzjnV17uIb33qn7vfF9B8duuCqw3dD7AN1wI9o0cKRsTwA@wte6q930q3aQ7wR0Uxtsqu3RBtw9CfACRhABqqikGRPzmheqXEO5rhlDgUWexPW28mXGOM8LGbE/77Y18M1PJhYGcMihp8Szz3RMApsx20QYcaWKMueWL/uPLPIWMUDTe9BgHcxmR@oE2C/F7hVqpyGWBCRItoerNa0GvcpiS1j4xukpdXxE8xh6DFcHk4CzgMvD/7O5R7PkUft3rO1rdzS02G2ftn4K0AIa1FtO5z9X6aZkiVIszQUoudlm3KYqy/NXAanl8VObcpcX23I95J@JieOBdOI6OTPeIMablWMhWWb9vCYB8ZpOHNUnfk48vyAYsxGzwC9kvvh1XLjnZtM9ar7/IP815daWLsvAtD13vY4ymS1D6F/qYTBOUx9zb8LkUWvOxo9G054RUlfWDVOgjLRVaxx9q98YGatbJTPO24OtZNqSocKn@OLMJRwGZC6vZPxQ1fuxoiOXWYIw@3Q72KSSZPDWBbD3u1T5pvgL "Python 2 – Try It Online") [Answer] # [Husk](https://github.com/barbuz/Husk), 5 bytes ``` €tİπd ``` [Try it online!](https://tio.run/##yygtzv7//1HTmpIjG843pPz//9/S2NLSGAA "Husk – Try It Online") ### Explanation ``` €tİπd 59 d Convert to base-10 digits [5,9] İπ The digits of pi [3,1,4,1,5,9..] t Remove the first element [1,4,1,5,9,2..] € Index of the sublist 4 ``` [Answer] # Excel, 212 bytes ``` =FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196") ``` Excel only handles 15 decimal places so pi is just hard-coded. This should be a pretty weak upper bound for this challenge. [Answer] # Java 8, ~~615~~ ~~217~~ ~~202~~ ~~184~~ ~~182~~ ~~166~~ 165 bytes (calculated ~~999~~ 200 digits) ``` n->{var t=java.math.BigInteger.TEN.pow(200);var r=t;for(int p=667;p-->1;)r=t.valueOf(p).multiply(r).divide(t.valueOf(p-~p)).add(t).add(t);return(r+"").indexOf(n,1);} ``` 1-indexed [Try it online.](https://tio.run/##hZBPS8QwEMXv@ymGnhK0YeviSgndg@DBg/Ww3sRDbNKamqYhnVaXpX71mu4f8CILE4bM@/GYN7UYRFzLz6kwouvgSWi7XwBoi8qXolCQz9/DAAqyRa9tBZbyMBzDC9WhQF1ADhYymGy82Q/CA2Z1cGaNwA92r6vH4Fcpz14ecubaL3KzXFI@cz5DXraezP4uW6/vuIvjTcJpENggTK@eS@Ioa3qD2pkd8ZRJPWipyB89/nGUMiElwXPjXmHvLfFXUUSZtlJ9B9JeJ5SPEz@u7vp3E1Y/JRhaLaEJBzjFfH0DQY/pt7sOVcPaHpkLEhpLLCtIlET0cIr/ifXtRSRdpenqInUmxsU4/QI) Java's builtin `Math.PI` has a precision of 15 decimal values, like many other languages. To have more digits, you'll have to calculate them yourself with `BigIntegers` or `BigDecimals`. This above is a way to do it.. ~~Maybe someone can golf this below 211 bytes, lol..~~ EDIT: Created a port of [@primo's Python 2 answer](https://codegolf.stackexchange.com/a/161164/52210) (make sure to upvote him!), so calculating being shorter than hard-coded is not so far-fetched anymore. ~~Just 7 more bytes to golf for it to be shorter.~~ -15 bytes thanks to @Neil, making it shorter than the hard-coded answer below! -36 bytes thanks to @primo. -1 byte changing `java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;` to `var T=java.math.BigInteger.TEN.pow(200);var r=T;`, because `var` is 1 byte shorter than `null` (gotta love the new Java 10). Explanation: ``` n->{ // Method with String parameter and integer return-type var t=java.math.BigInteger.TEN.pow(200); // Temp BigInteger with value 10^200 var r=t; // Result BigInteger, also starting at 10^200 for(int p=667; // Index-integer, starting at 667 p-->1;) // Loop as long as this integer is still larger than 1 // (decreasing `p` by 1 before every iteration with `p--`) r= // Replace the Result BigInteger with: t.valueOf(p) // `p` .multiply(r) // multiplied by `r`, .divide(t.valueOf(p-~p)) // divided by `2p+1` .add(t).add(t); // And add 210^200 return(r+"") // Convert the BigInteger to a String .indexOf(n, // And return the index of the input, 1);} // skipping the 3 before the comma ``` --- # Java 8, 211 bytes (hard-coded 200 digits) ``` "14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf ``` 0-indexed [Try it online.](https://tio.run/##hZBNbgIxDIX3nCKaFSyKbMdObFCPULpgWXUxHQY0FAJiBtSq4uzT8NNlhZQosvM@W@@ty1P5tF589tWmbFv3UjbpZ@Bck7r6sCyr2s0u5bXhquG8OzRp5dJompvnfPNpu7JrKjdzyT27vkBGMQriRS2aJ68cKLD36imaAKkyWsRg3sxHQRAlsMjGnEEPUTEwBNJAoGb5UfCsJJ4JMUKIpoSsoEHQk2YkBI5geRMHMJHLRPIYMyLGoEjKipnly3pGoAiY5ZLngYhYyCCRsZqwefCKForJpEmL@ut12U9vRvfHj002evd72jULt81x3UN5e3fl6JbV/Lvt6u14d@zG@/zVbdIwjathgcXoGtz/iiAPJdfYHqr@FOfBuf8F) [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes ``` ₁žs¦¹k ``` [Try it online!](https://tio.run/##MzBNTDJM/f//UVPj0X3Fh5Yd2pn9/78xAA "05AB1E – Try It Online") How? ``` ₁ push 256 žs push pi to 256 places ¦ remove the leading 3 ¹ push the input k index inside that string ``` [Answer] # [MATL](https://github.com/lmendo/MATL), ~~16~~ 15 bytes ``` YP8WY$4L)jXfX<q ``` [Try it online!](https://tio.run/##y00syfn/PzLAIjxSxcRHMysiLcKm8P9/S2NLS2MA) ### Explanation ``` YP % Push pi as a double 8W % Push 2^8, that is, 256 Y$ % Compute pi with 256 significant digits using variable-precision arithmetic % The result as a string 4L) % Remove first character. This is to avoid finding '3' in the integer part % of pi j % Push input as a string Xf % Strfind: gives array of indices of occurrences of the input string in the % pi string X< % Mimimum q % Subtract 1. Implicitly display ``` [Answer] # [R](https://www.r-project.org/) + numbers package, 52 bytes ``` regexec(scan(),substring(numbers::dropletPi(200),3)) ``` [Try it online!](https://tio.run/##K/r/vyg1PbUiNVmjODkxT0NTp7g0qbikKDMvXSOvNDcptajYyiqlKL8gJ7UkIFPDyMBAU8dYU/O/8X8A "R – Try It Online") `dropletPi` computes the first 200 decimal digits of `pi` but includes a `3.` at the beginning, so we strip that out with `substring` and then match with `regexec`, which returns the index of the match along with some metadata about the match. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 23 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` ⁵⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SṾḊw ``` A monadic link accepting a list of characters (the integer to find) and returning the index. Works for inputs contained within the first 252 digits of the decimal part of π. [Try it online!](https://tio.run/##y0rNyan8//9R41atR407H@5YYn1i@8MdXdpeKoeWHJ4OFLIyOrTE6uT0mOCHO/cBJcr///@vbmlsaWmsDgA "Jelly – Try It Online")* ### How? This uses the [Leibniz formula for π](https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80) to calculate the first 253 digits including the leading `3` (plus four trailing incorrect digits). The leading `3` is then dropped and the index of the input is found: ``` ⁵⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SṾḊw - Link: list of characters ⁵ - literal ten ⁹ - literal 256 - exponentiate = 10000...0 (256 zeros) Ḥ - double = 20000...0 ¤ - nilad followed by links as a nilad: ȷ - literal 1000 Ḋ - dequeue -> [2,3,4,5,...,1000] $ - last two links as a monad: J - range of length -> [1,2,3,4,...,999] + - addition (vectorises) -> [3,5,7,9,...,1999] ; - concatenate -> [20000...0,3,5,7,9,...,1999] \ - cumulative reduce with: ɗ - last three links as a dyad: ¤ - nilad followed by link(s) as a nilad: ⁹ - chain's right argument (the right of the pair as we traverse the pairs in the list -- 3, 5, 7, 9, ...) 2 - literal two : - integer division (i.e. 1, 2, 3, ...) × - multiply (the left of the pair, the "current value", by that) : - integer divide by the right argument (i.e. 3, 5, 7, 9, ...) S - sum up the values (i.e. 20000...0 + 66666...6 + 26666...6 + 11428...2 + ... + 0) Ṿ - un-evaluate (makes the integer become a list of characters) Ḋ - dequeue (drop the '3') w - first (1-based) index of sublist matching the input ``` If you prefer a list of digits as input use `⁵⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw` (also 23), while if you really want to give it an integer use `⁵⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD` (for 24). [Answer] # BASH (GNU/Linux), ~~75~~ ~~67~~ 66 bytes Saved 1 byte thanks to Sophia Lechner, and 7 bytes thanks to Cows quack. ``` a=`bc -l<<<"scale=999;4a(1)"\|tail -c+2\|grep -ob $1`;echo ${a%%:} ``` This is a shell script that takes a single argument, which is the number. Test with ``` $ bash <script-path> 59 4 ``` This script first executes a pipeline of three commands: ``` bc -l<<<"scale=999;4a(1)"\| #produce pi with its first 999 fractional digits tail -c+2\| #cut off the "3." grep -ob $1 #compute the byte offsets of our argument in the string ``` The result of this pipeline is assigned to the shell variable `a`, which is then echoed out with anything but the first number removed: ``` a=`...`; #assign the result of the pipeline to a variable echo ${a%%:} #cleave off the first : character and anything following it ``` --- Unfortunately, `bc` has the tendency to break output lines when they become too long. This may lead to wrong results if the number to be found is not on the first line. You can avoid that by setting the environment variable `BC_LINE_LENGTH`: ``` export BC_LINE_LENGTH=0 ``` This deactivates the line breaking feature completely. --- Obviously, the last two commands may be omitted if other output is tolerated. This gives a count of 48 bytes: ``` bc -l<<<"scale=999;4a(1)"\|tail -c+2\|grep -ob $1 ``` With the resulting output: ``` $ bash <script-path> 59 4:59 61:59 143:59 179:59 213:59 355:59 413:59 415:59 731:59 782:59 799:59 806:59 901:59 923:59 940:59 987:59 ``` [Answer] # JavaScript, ~~197~~ 187 -10: Thanks, [Neil](https://codegolf.stackexchange.com/users/17602/neil)! ``` x=>"50ood0hab15bq91k1j9wo6o2iro3by0h94bg3geu0dnnq5tcxz7lk62855h72el61sx7vzsm1thzibtd23br5tr3xu7wsekkpup10cek737o1gcr6t00p3qpccozbq0bfdtfmgk".replace(/.{9}/g,a=>parseInt(a,36)).search(x)+1 ``` Takes a series of nine-digit base-36 integers, converts them to base 10, and concatenates them to create the first 200 digits of pi. [Answer] First time doing code golf. Use delegates and lambda expressions to reduce the function calls. V2 shorten class name into a single byte. # [C#], ~~361~~ 355 bytes ``` using System;class P{static void Main(){Func<string,int>F=f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;Action<int>w=Console.WriteLine;w(F("1"));w(F("65"));w(F("93993"));w(F("3"));}} ``` Formatted version:* ``` using System; class P { static void Main() { Func<string,int>F=f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1; Action<int>w=Console.WriteLine; w(F("1")); w(F("65")); w(F("93993")); w(F("3")); } } ``` [Ideone!](https://ideone.com/xMp2Kg) NB.I miscounted the first version. It was 361 bytes, not 363 bytes. # [C#], tio version 218 bytes ``` f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1 ``` [Try it online!](https://tio.run/##hZDBSsNAEIbP5imWnBLUsjM7sztDbS9CQVAUPHgOaVoCbQLZVJTSZ4/bonjsXGYYvu8fmDre17GeDrHttub9O47Nfp5l9a6K0bwN/Xao9tkxM6niWI1tbT77dm1eqrYrysv6mN2sDl39EMchRdy13bg0K7OYNotlDgSs6NmxaFCHTsijJ@fEYVC2KEKgAbw6VRcYLAtaDaRESXQ2CHiyHsWjFdXUxDoSZEcIEKwPKggkVjyDQ0mK9xSspkvkrTKfE9FBSAorWQEUEkgunc8TWAwWEs4pzzKz@iQiKokyqbNOQH0@e@rWzdfrptiUtzCZ35pnf9Nj38V@18w@hnZsntuuKVZFDnlZXkE8X2cuv7mO/SOn7DT9AA) [Answer] # [Haskell](https://www.haskell.org/), ~~208~~ 120 bytes ``` a=1333 x=tail$show$foldr(\p x->p`div`2x`div`p+210^200)a[3,5..a] x!n\|take(length n)x==n=0\|1<2=1+tail x!n f n=1+x!show n ``` [Try it online!](https://tio.run/##Vc3LTsMwEAXQvb/iJsqiD1rFNgVFwixgWUQrsUHioVjEbqIaJ2pcMFK/HeNmFVYzczRzp5b9XhkTghSUc068cLIxWV@335luTXWYvHbwi9uurJqvks38ULs5m9H8neX5VL7wi9VyKd@IT@zJyb2aGGV3roadeiGsyE/0hgk6P@ci7hANG0efnH/ABo8ydkdT3akSPxDoju7JHR4sMjQaHkJEdrWySDfrFMr0Culj67BZJykhn7Kx8apqCaBBx2l0oKvV2K4HK3hR8DFfssH/WRF@P7SRuz4snu@32z8 "Haskell – Try It Online") Many thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan) for his suggestions! ### Old version (208 bytes) ``` (+1).((tail$g(1,0,1,1,3,3))!) g(q,r,t,k,n,l)=([n:g(10q,10(r-nt),t,k,div(10(3q+r))t-10n,l)\|4q+r-t<nt]++[g(qk,(2q+r)l,tl,k+1,div(q(7k+2)+rl)(tl),l+2)])!!0 x!n\|take(length n)x==n=0\|1<2=1+tail x!n ``` I actually don't know how the code above works; I've taken it from [this paper](https://www.cs.ox.ac.uk/jeremy.gibbons/publications/spigot.pdf) and all I implemented was the lookup part. `g(1,0,1,1,3,3)` returns the digits of pi and is surprisingly efficient (it computes 10 000 digits on tio.run in less than 4s). The input is a list consisting of the digits of the number to be found. [Try it online!](https://tio.run/##VZDLasMwEEX3/oqxyUIvF8tOG1yiTbtMaQLZFNxATCM/sKrUtlJcyLfXHQcCjQYNzD33DkhV3jfamLFQ7yPhkt4R4vLazEoiRSQkViISSn3qlaQVnXCiEVYYqkhmH9EUsVZgI11omaMXfKi/J50krOUdpS7EYYqc55MQuiU6d5xnuJA1gsQXGzPC4W24vORbRhas4THlHTOUIKLC4Lijvh95g2/PLm80MdqWrgJLB6Wsis5yGSvJpwcAesYB9n11PJnDk97DDyj4Ormt614szKAuYAClUHaVthCsVwFo02sIXo8O1is/8LzPvLaYOhw9wFNAJnf/N8qr/CDub8DiClL8vRQrucHz@Mpv9XT8/ShMXvZj@Pa82fwB "Haskell – Try It Online") [Answer] # Haskell, 230 bytes Using laziness to find the number anywhere in the infinite digits of pi, not just in the first 200 digits. Oh yeah, and it returns you every (infinitely many?) instance(s) of the number, not just the first one. ``` p=g(1,0,1,1,3,3)where g(q,r,t,k,n,l)=if 4q+r-t<nt then n:g(10q,10(r-nt),t,k,div(10(3q+r))t-10n,l) else g(qk,(2q+r)l,tl,k+1,div(q(7k+2)+rl)(tl),l+2) z n=[(i,take n$drop i p)\|i<-[1..]] f l=[n\|(n,m)<-z$length l,m==l] ``` ## Examples from the challenge ``` > take 10 $ f [1] [1,3,37,40,49,68,94,95,103,110] > take 10 $ f [6,5] [7,108,212,239,378,410,514,672,870,1013] > take 1 $ f [9,3,9,9,3] [42] > take 10 $ f [3] [9,15,17,24,25,27,43,46,64,86] ``` ## Credits 'p' is the infinite stream of pi digits, taken from <https://rosettacode.org/wiki/Pi#Haskell> ``` > take 20 p [3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4] ``` [Answer] # SmileBASIC, ~~179~~ 164 bytes ``` INPUT I$FOR I=0TO 103Q$=Q$+STR$(ASC("\A#YO &.+& O2TGE']KiRa1,;N(>VYb>P0uCb0V3 RB/]T._2:H5;(Q0oJ2)&4n7;@.^Y6]&"[I]))NEXT?INSTR(Q$,I$)+1 ``` Digits of pi are hardcoded and packed into the ascii values of characters. 14 -> `CHR$(14)`, 15 -> `CHR$(15)`, 92 -> `\`, 65 -> `A`, 35 -> `#`. The string contains unprintable characters, so here are the bytes written in hexadecimal: `0E 0F 5C 41 23 59 4F 20 26 2E 1A 2B 26 20 4F 32 1C 54 13 47 45 27 5D 4B 69 52 00 61 31 2C 3B 17 00 4E 10 28 3E 56 14 59 62 3E 50 03 30 19 03 2A 75 00 43 62 15 30 00 56 33 20 52 1E 42 2F 00 5D 54 2E 00 5F 32 3A 16 1F 48 35 3B 28 51 1C 30 6F 4A 32 1C 29 00 1B 00 13 26 34 6E 37 3B 40 2E 16 5E 59 36 5D 00 26 13 06` In decimal, you can see the digits of pi: `14 15 92 65 35 89 79 32 38 46 26 43 38 32 79 50 28 84 19 71 69 39 93 75 105 82 0 97 49 44 59 23 0 78 16 40 62 86 20 89 98 62 80 3 48 25 3 42 117 0 67 98 21 48 0 86 51 32 82 30 66 47 0 93 84 46 0 95 50 58 22 31 72 53 59 40 81 28 48 111 74 50 28 41 0 27 0 19 38 52 110 55 59 64 46 22 94 89 54 93 0 38 19 6` [Answer] # [Ruby](https://www.ruby-lang.org/), ~~37~~ 35 bytes ``` p"#{BigMath::PI 200}"[3..-3]=~/#$_/ ``` [Try it online!](https://tio.run/##KypNqvz/v0BJudopM903sSTDyirAU8HIwKBWKdpYT0/XONa2Tl9ZJV7//39LY0tL43/5BSWZ@XnF/3XzipIy01NSkzNzE3P0c4E6AQ "Ruby – Try It Online") Nothing special, just showcasing the built-in library. Output is 0-indexed. The Pi string is formatted as `0.31415...e1`, so we need to strip off the first 3 chars. The `e1` part in the end doesn't really do any harm, but it is stripped off too, as we need to provide a range end (or slice length) value anyway. [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal), ~~27~~ 15 bytes ``` Ｉ⊖∨⌕Ｉ▷N⟦≕Piφ⟧θχ ``` [Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwyU1uSg1NzWvJDVFw79Iwy0zLwUi4VqWmFOaWJIalliUmZiUk6qh5KekoxDtnlqCEAnIVNLUUTA0MDCI1QQyCsEcTSCw/v/f@L9uWQ4A "Charcoal – Try It Online") Link is to verbose version of code. Works up to nearly 1000 digits. Explanation: ``` ≕Pi Get variable `Pi` φ Predefined variable 1000 ▷N⟦ ⟧ Evaluate variable to specified precision Ｉ Cast to string θ First input ⌕ Find χ Predefined variable 10 ∨ Logical OR ⊖ Decrement Ｉ Cast to string Implicitly print ``` [Answer] # [Japt](https://github.com/ETHproductions/japt), ~~186~~ 177 bytes ``` `nqnrvosrpruvtvpopuqsosqppÕÝvr¶uuqnvtnsvpvvptrnmruomvtqvqqrvopmÉæqÛàÑ$vvÔàmpqupqm¡vuqum«rnpopmssqtmvpuqqsmvrrmruoopÌÊprvqÛ$uqunnqr¶uqn¶tmnvpÔnmrrrvsqqsoovquvrqvpmpunvs`®c -#mÃbU ``` Since Japt shares Javascript's 15-digit Pi constraint and [shoco](http://ed-von-schleck.github.io/shoco/), the encoding used by Japt, doesn't encode numbers, some shenanigans are required for compression. Shortly explained, the beginning is the below string in encoded form: ``` "nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs" ``` Which is a string where each letter is `'m' + corresponding digit of pi`. I tested the whole alphabet and that letter gives the best compression by a few bytes. Backticks tell Japt to decode the string. The rest of it is pretty straightforward: ``` ®c -#mÃbU ® // Given the above string, map each letter c // and return its charcode -#m // minus the charcode of 'm', 109. Ã // When that's done, bU // find the index of the implicit input U. ``` Outputs 0-based index of the matching fragment. Shaved another two bytes off thanks to [Oliver](https://codegolf.stackexchange.com/users/61613/oliver). [Try it online!](https://tio.run/##FY09ToJBEIavQiKtFY0XoUftSGZ23pmd9wJWEhsTrAgJNDQmlhxg52CfS//87F@tL8tOoc4Wbp7stGaJaAGz@qkzfdwzoewaNNK6q3g2YQeBKZrUZ91Qp7rU95qsY13EkAYZVyZSxq/rzEoEunDmEUL3R6ZZfdXBnNNfT1YVjyF03LsorY7z5s6YTmtE0kETS2Xsxt/76vlJ6uNtuyybzcs/) [Answer] # [AWK](https://www.gnu.org/software/gawk/manual/gawk.html) -M , ~~131 119~~ 117 bytes Uses `-M` flag for arbitrary precision calculations. Added `p=k=0` (5 bytes) to the TIO link to allow multi-line input ``` {CONVFMT="%.999f";PREC=1e3;for(p=k=0;k<1e3;)p+=(4/(8k+1)-2/(8k+4)-1/(8k+5)-1/(8k+6))/16^k++;$0=$1==3?9:index(p,$1)-2}1 ``` [Try it online!](https://tio.run/##SyzP/v@/2tnfL8zNN8RWSVXP0tIyTck6IMjV2dYw1dg6Lb9Io8A229bAOtsGxNcs0LbVMNHXsNDK1jbU1DWCsEw0dQ0hLFM4y0xTU9/QLC5bW9taxcBWxdDW1tje0iozLyW1QqNARwWkudbw/39DBTDILy0pKC1RsFIw5DIzRRUx57I0trQ0RhIxMeIyRtNmyfUvv6AkMz@v@L@uLwA "AWK – Try It Online") Explanation:* ``` {CONVFMT="%.999f"; # Allows 999 decimal digits to be used when numbers are convert to strings PREC=1e3; # Digits of precision to use for calculations for(;k<1e3;)p+=(4/(8k+1)-2/(8k+4)-1/(8k+5)-1/(8k+6))/16^k++; # The most concise numerical calculation I could find. It doesn't converge extremely rapidly, but it seems to work OK $0=$1==3?9:index(p,$1)-2} # Replace input line with either 9 or index-2 # since indices will either be 1 (meaning 3 was input) or >= 3 1 # Print the "new" input line ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 24 bytes ``` ȷ* ȷR×¢:Ḥ‘$ƲU×:¢+¢ʋ/ḤṾḊw ``` [Try it online!](https://tio.run/##ATkAxv9qZWxsef//yLcqCsi3UsOXwqI64bik4oCYJMayVcOXOsKiK8Kiyosv4bik4bm@4biKd////yc2NSc "Jelly – Try It Online") ~~Use a [Machin-like formula](http://mathworld.wolfram.com/Machin-LikeFormulas.html), specifically 1/4 pi == tan-1(1/2) + tan-1(1/3).~~ Use the formula pi/2 == 1 + 1/3 × (1 + 2/5 × (1 + 3/7 × (1 + 4/9 × ( ... )))) [Answer] ## Python 2 ~~239~~ ~~238~~ ~~229~~ 214 bytes -9 bytes due to [@primo](https://codegolf.stackexchange.com/users/4098/primo) ``` from bigfloat import;a=s=n=10105;b=k=0 while a:k+=1;a=k(k(108-72k)-46)+5;a/=k3(640320*3/24);s+=a;b+=ka with precision(10*7):print`(426880sqrt(10005n)n)/(13591409s+545140134b)`.find(input())-16 ``` Uses the Chudnovsky-Ramanujan algorithm to find the first ~~1 million digits~~ 50000 digits of π (change `10105` to `10106` for more, but it takes ages to run) and then searches them for the desired string. [Answer] ## Javascript 217 bytes (200 hardcoded) ``` a=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".search(a)+1 ``` [Answer] ### PHP, 27 bytes Not a very serieus answer, it requires a change in the php.ini settings as pi() defaults to 14 digits, not 200, but for once the PHP solution is fairly elegant: ``` <?=strpos(pi(),$_GET[n])-1; ``` [Answer] # [Julia 0.6](http://julialang.org/), 53 bytes ``` setprecision(9^6) x->searchindex("$(big(π))","$x",3) ``` Set the precision for BigFloats high enough, then convert `pi` to a string and search. Precision of `9^6` handles 159980 digits. [Try it online!](https://tio.run/##DctLCsIwEADQtTlFGFpIYFxIaCALxXv4gX6SOCLTklaYpTf0SNG3f8/3i3pf03GImbiucVtKHGmlmU24e6tkf1pjX8YH8RTFQGMGyub7sRYQGgF0tkaeVJqLFk2sLwf0HXYBgwvBobup3XkpxFsy0Pqs23xlQMFkxFr1r/UH "Julia 0.6 – Try It Online") [Answer] # J, 25 Bytes ``` {.I.(}.":<[[email protected]](/cdn-cgi/l/email-protection)^999)E.~ ``` [Try it online!](https://tio.run/##y/r/PzU5I1@hWs9TT6NWT8nKRs8hX8/QoCLO0tJS01WvTkHdEgzU//8HAA "J – Try It Online") 0-Indexed Takes input as a string, +2 Bytes (`":`) if that's not allowed. Explanation eventually. [Answer] ## [Perl 5](https://www.perl.org/) with `-MMath::BigFloat+bpi` and `-n`, 20 bytes ``` bpi($>)=~/.$_/;say@- ``` [Try it online!](https://tio.run/##K0gtyjH9/z@pIFNDxU7Ttk5fTyVe37o4sdJB9/9/Qy4zUy5LY0tLYy5jLgtDSy4zExOjf/kFJZn5ecX/dX1N9QwMDYC0b2JJhpWVU2a6W05@Yok20LD/unk5AA "Perl 5 – Try It Online") I'm not sure where usage of `$>` stands, since it's the `EFFECTIVE_USER_ID` which is not portable, but on TIO this is 1000 and satisfies our requirement, for -1 byte vs. `200`. [Answer] # [Husk](https://github.com/barbuz/Husk), 5 bytes ``` €tİπd ``` [Try it online!](https://tio.run/##yygtzv7//1HTmpIjG843pPz//9/S2NLSGAA "Husk – Try It Online") ``` € The 1-based index as a substring of d the decimal digits of the input İπ in the infinite list of digits of pi t after the radix point. ``` [Answer] # [JavaScript (Node.js)](https://nodejs.org) (ES2020), 75 bytes ``` n=>`${eval(`for(a=c=2n10n300n,d=1n;a=d;)c+=a/=d+++d`)}`.search("."+n)+1 ``` [Try it online!](https://tio.run/##BcFLCsMgEADQu4Qu1Gmt1pWEyVkc/PSDjEFLNqFnt@996KAR@3v/3rilPAtOxi1cznxQFaG0LggjPlhZw0o5Y/ia0PJKCtMqIyDdMQFACvIX9MjU40ssegGWYGdsPFrNuranKMI7752U8w8 "JavaScript (Node.js) – Try It Online") Uses the formula I've used in another Pi-related challenge. `search("."+n)` is needed to drop the leading `3`. Change `300` to a higher number gives more precision. ]
[Question] [ This competition is over. The winner is CJam with 22 characters, beating [TwiNight](https://codegolf.stackexchange.com/users/6972/twinight)'s answer by one character. Congratulations [Dennis](https://codegolf.stackexchange.com/users/12012/dennis)! An honorable mention goes to [Falko](https://codegolf.stackexchange.com/users/30372/falko), who went totally crazy with the free imports. . --- A while ago [I wanted to know](https://codegolf.stackexchange.com/questions/24696/optimizing-the-telephone-keypad) how I can out-type modern smartphones with my Nokia 3310, and while some answers were really good, I still can't keep up! Maybe I should take a different approach and simply not write any words that are awkward to type. We'll call a piece of text easily typeable if no two consecutive letters are on the same button on the telephone keyboard, given the standard layout: ![Telephone Keyboard](https://i.stack.imgur.com/WYOQu.png) --- ## Your task Your task is to write a program/function that accepts a string `s` from stdin/as a parameter and returns a truthy value if `s` is easily typeable and a falsy value otherwise. The input will only consist of lowercase letters and spaces and is guaranteed to be non-empty! ## Scoring This is codegolf, so lowest character-count wins. Import statements will not be counted towards your final score, so if you've ever wanted to use `std::set_symmetric_difference`, `liftM4`, or `itertools.combinations` in your code, now is the time! -3 if your source code is easily typeable, assuming everything that's not a letter is on button 0. After all, I might want to message your code to some friends! ## Testcases Here are a few testcases to check if your code is working as intended: ``` "x" -> True "aardvark" -> False "ardvark" -> True "flonk" -> False "im codegolfing all day long" -> False "i indulge in minimizing bytecount" -> True "havent heard from you in a long time" -> False "your silence was of undue permanence" -> True "how are you" -> False "how are you" -> True ``` Happy golfing! [Answer] # Python 2 - ~~80, 68, 64, 61, 58, 50, 48, 45, 44~~ 42 Even though it's getting a little ridiculous now, I'll keep on making use of free library imports, even the `__builtin__` library: ``` from numpy import diff as D from pprint import pprint as P from __builtin__ import all as A from __builtin__ import raw_input as I from __builtin__ import bytearray as B ``` So only the following short line counts towards the code length: ``` P(A(D([(o-o/112-o/59)/3for o in B(I())]))) ``` Credits to Markuz for the ideas regarding `input()`! These free-import challenges always introduce you to some lesser known libraries. ;) --- Alternative using only the `operator` library (~~98, 83~~ 79): ``` from operator import ne as n K=[(ord(c)-1-(c>'p')-(c>'w'))/3for c in input()] print all(map(n,K[1:],K[:-1])) ``` I'll stop here. But you could further golf this version using `sys`, `pprint` and other libraries... --- Alternative without libraries (105): ``` s=input() n=lambda c:(ord(c)-1-(c>'p')-(c>'w'))/3 print all([n(s[i])!=n(s[i+1])for i in range(len(s)-1)]) ``` [Answer] # ~~Ruby~~ Regex (most popular flavours), ~~106~~ 83 bytes Because regex ``` ^(?!.( \|[abc]{2}\|[def]{2}\|[ghi]{2}\|[jkl]{2}\|[mno]{2}\|[p-s]{2}\|[tuv]{2}\|[w-z]{2})) ``` I've just cut the middleman (Ruby) and made this a pure-regex solution. Works in a lot of flavours and only finds a match if the string does not contain two consecutive characters on the same button. [Answer] # Bash+coreutils, 49 ``` tr a-z $[36#8g7e9m4ddqd6]7778888\|grep -Pq '(.)\1' ``` Returns an exit code of 1 for TRUE and 0 for FALSE: ``` $ for s in "x" "aardvark" "ardvark" "flonk" "im codegolfing all day long" "i indulge in minimizing bytecount" "havent heard from you in a long time" "your silence was of undue permanence" "how are you" "how are you"; do echo "./3310.sh <<< \"$s\" returns $(./3310.sh <<< "$s"; echo $?)"; done ./3310.sh <<< "x" returns 1 ./3310.sh <<< "aardvark" returns 0 ./3310.sh <<< "ardvark" returns 1 ./3310.sh <<< "flonk" returns 0 ./3310.sh <<< "im codegolfing all day long" returns 0 ./3310.sh <<< "i indulge in minimizing bytecount" returns 1 ./3310.sh <<< "havent heard from you in a long time" returns 0 ./3310.sh <<< "your silence was of undue permanence" returns 1 ./3310.sh <<< "how are you" returns 0 ./3310.sh <<< "how are you" returns 1 $ ``` [Answer] ## APL(Dyalog), ~~24~~ 23 ``` ~∨/2=/⌊¯13⌈.21-.31×⎕AV⍳⍞ ``` --- ``` ∧/2≠/⌊¯13⌈.21-.31×⎕AV⍳⍞ ``` Explanation* `⍞`: Takes string input from screen `⎕AV`: This is the atomic vector which is bascially a string of all characters APL recognizes, which of course include all lowercase letters (index 18~43) and space (index 5) `⍳`: `IndexOf` function. For many functions in APL that takes one or two scalar arguments, you can feed it an array in place of a scalar - APL will do the looping for you. So `⍳` returns a numeric array of indices. `.21-.31×`: Times 0.31 and then subtract from 0.21. This is a little trick that maps letter on the same key (especially PQRS) to the same number (when rounded down to integers), except Z, which get mapped to its own group `¯13⌈`: `max` with -13. This brings Z back to the group with WXY `⌊`: Round down to integers `2≠/`: Pairwise-`≠`. Returns a boolean array for each consecutive pair. `∧/`: AND together all entries of the resulting array. [Answer] ## Perl - 44 This is basically a Perl adaptation of @DigitalTrauma's [answer](https://codegolf.stackexchange.com/a/37578/29438) posted with his permission. Shaved off 2 characters thanks to @KyleStrand. ``` y/b-y/aadddgggjjjmmmpppptttzzz/;$_=!/(.)\1/ ``` 43 characters + 1 for `-p` flag. `y///` is the same as `tr///`. It prints `1` for true and nothing for false. I can post a detailed explanation if requested. Example run: ``` perl -pE'y/b-y/aadddgggjjjmmmpppptttzzz/;$_=!/(.)\1/' <(echo "x") ``` --- ## Perl - 81 ``` $s=join"]{2}\|[",qw(abc def ghi jkl mno p-s tuv w-z);say/^(?!.( \|[$s]{2}))/?1:0 ``` +1 for `-n` flag. It works by using `join` to create the regex (same one as [Martin's](https://codegolf.stackexchange.com/a/37578/29438)), which shaves of a few bytes. Example run: ``` perl -nE'$s=join"]{2}\|[",qw(abc def ghi jkl mno p-s tuv w-z);say/^(?!.( \|[$s]{2}))/?1:0' <(echo "your silence was of undue permanence") ``` [Answer] # CJam, ~~34~~ ~~31~~ ~~27~~ 22 characters ``` 1l{'h-_9/-D+3/X\:X^}/ ``` [Try it online.](http://cjam.aditsu.net/ "CJam interpreter") ### Example run ``` $ cjam <(echo "1l{'h-_9/-D+3/X\:X^}/") <<< 'aardvark'; echo 0 $ cjam <(echo "1l{'h-_9/-D+3/X\:X^}/") <<< 'ardvark'; echo 66000 ``` ### How it works ``` 1l " Push a R := 1 and read a line L from STDIN. "; " Initialize X := 1. (implicit) "; { }/ " For each character C of L, do the following: "; 'h- " C -= 'h' "; _9/-D+3/ " Y := (C - C / 9 + 13) / 3 "; X\ ^ " R = X ^ Y "; :X " X := Y "; " Print R. (implicit) "; ``` ### Background The core of the code consists in applying a map F* to each character C of the input string so that the images of symbols on the same key match. I found the a suitable map by observing the following: The map T : C ↦ (C - 'h') + 13 transforms the string S := " abcdefghijklmnopqrstuvxyz" as follows: ``` [-59 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31] ``` For the keys `0` to `6`, it would suffice to divide T(C) by 3, but we have to apply some sort of correction to the characters in s, t, v, y and z. The map D : C ↦ (C - 'h') / 9 transforms the string S into the following array: ``` [ -8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 2] ``` This corrects the quotients of s, t, v, y and z, without affecting the others. Finally, the map F : C ↦ (T(C) - D(C)) / 3 transforms the string S as follows: ``` [-17 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 7 8 8 8 9 9 9 9] ``` All that rests is to compare the consecutive characters somehow. For that purpose, we XOR F(C) with the image of the previous character – for the first, we XOR F(C) with 1 (default value of the variable X), which has no preimage – and multiply all the results. The product will be falsy if and only if one of the factors is zero, i.e., if and only if two consecutive characters have the same image by F. [Answer] # JavaScript - 159 156 bytes ``` function g(s){p=n=-1;for(i=0;i!=s.length;i++){p=n;n=s.charCodeAt(i);n-=97;if(n>17)n--;if(n>23)n--;if(p==-1)continue;if(~~(p/3)==~~(n/3))return 0;}return 1;} ``` Returns 1 for truthy and 0 for falsy. If only I could get rid of the keywords. [Answer] # c, 74 bytes ``` main(c,d,r){for(;~(c=getchar());r=d!=c/3,d=c/3)c-=--c/'p'(c-'k')/7;c=r;} ``` Returns a non-zero exit status for TRUE and 0 for FALSE: ``` $ for s in "x" "aardvark" "ardvark" "flonk" "im codegolfing all day long" "i indulge in minimizing bytecount" "havent heard from you in a long time" "your silence was of undue permanence" "how are you" "how are you"; do echo "./3310 <<< \"$s\" returns $(./3310 <<< "$s"; echo $?)"; done ./3310 <<< "x" returns 40 ./3310 <<< "aardvark" returns 0 ./3310 <<< "ardvark" returns 216 ./3310 <<< "flonk" returns 0 ./3310 <<< "im codegolfing all day long" returns 0 ./3310 <<< "i indulge in minimizing bytecount" returns 72 ./3310 <<< "havent heard from you in a long time" returns 0 ./3310 <<< "your silence was of undue permanence" returns 232 ./3310 <<< "how are you" returns 0 ./3310 <<< "how are you" returns 8 $ ``` [Answer] ## Ruby 1.8, ~~89~~ ~~83~~ ~~81~~ 78 bytes ``` p$[0].chars.map{\|c\|c=c[0];(c-c/?p-c/?w-1)/3}.each_cons(2).map{\|a,b\|a!=b}.all? ``` Here is another submission. To my shame, it beats the regex. :( This takes the string via command-line argument and prints a boolean. As for the algorithm, I'm shifting down the letters after `p` by one and after `z` by two, and then I check that there are no collisions after integer division by 3. PS: This is the first time, that using Ruby 1.8 shortened the code (due to the shorter way to get character codes). [Answer] # Cobra - 80 ``` def f(s) for c in s for x in 9,if' adgjmptw'[x]>c,break t,f=x,t<>x print f ``` [Answer] # JavaScript (ES6) 66 ~~74~~ ``` F=s=>[...s].every(c=>[...' adgjmptw'].map(x=>s+=c<x,w=s,s=0)\|s!=w) ``` The inner loop find the group for each character. Conceptually is a 'reduce' but 'map' is shorter. The outer loop compare the group of consecutive chars and exits with false if they are equal. Test* In Firefox/Firebug console ``` ;["x","aardvark","ardvark","flonk","im codegolfing all day long", "i indulge in minimizing bytecount","havent heard from you in a long time", "your silence was of undue permanence","how are you","how are you"] .forEach(x=>console.log(x + ' -> ' + F(x))) ``` Output ``` x -> true aardvark -> false ardvark -> true flonk -> false im codegolfing all day long -> false i indulge in minimizing bytecount -> true havent heard from you in a long time -> false your silence was of undue permanence -> true how are you -> false how are you -> true ``` [Answer] # Perl, 83 bytes ``` $_=<>;chop;map{$_=ord;$_=($_-$_/112-$_/119-1)/3;die 0 if$l==$_;$l=$_}split//;die 1 ``` Making heavy abuse of $\_ in Perl. [Answer] Two tasks are tricky in Python; detecting chains, and assigning the groups. Both can be assisted using numpy, but it is not in the standard library. # Python 2 (only standard library) - 59 chars function ``` from itertools import imap as M from __builtin__ import bytearray as A, all as E from operator import ne as D, not_ as N from re import S, sub as X, search as F # 68 #def f(s): # g=[(n-n/115-n/61)/3for n in A(s)] # return E(M(D,g,g[1:])) # 67 with regex via regex #f=lambda s:N(F(X('(\S)(.)',r'\|[\1-\2]{2}',' acdfgijlmopstvwz'),s)) # 59 slightly optimized ordinal classifier and regex sequence detector f=lambda s:N(F(r'(.)\1',A((n-n/23-n/30)/3for n in A(s)),S)) # 69 using itertools.groupby #from itertools import groupby as G #from __builtin__ import sum as S, len as L #f=lambda s:N(S(L(A(g))-1for _,g in G((n-n/115-n/61)/3for n in A(s)))) ``` # Python 2 (only standard library) - 53 chars stdin to exit value Here I abuse the fact that `issubclass(bool,int)`, so changing `all()` to `any()` gets me a valid exit value, shaving off the `not()` from the return value. The removal of function overhead made the regex versions fall behind in size. ``` from itertools import groupby as G, imap as M from __builtin__ import bytearray as A, any as E from __builtin__ import raw_input as I from sys import exit as Q from operator import eq as S g=[(n-n/23-n/30)/3for n in A(I())] Q(E(M(S,g,g[1:]))) ``` [Answer] # J - 42 char Function taking string on the right. ``` /@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.) ``` First we map the alphabet (`u:97+i.26`) into the numbers 0 through 25, all other characters (including spaces) going to 26 (`i.`). Then we map (`{~`) the first three elements map to the first key, the next three to the next key, and so on through the keys of the phone pad, making sure to map the space/other punctuation to a separate key at the end. (`4 3 4 1,~5#3` is equal to `3 3 3 3 3 4 3 4 1` and `I.` turns that into a 27-item array where the first three are key 1, etc.) Then we check for pairwise inequality (`2~:/\`) and AND all the results together (`/`). ``` /@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.) 'i indulge in minimizing bytecount' 1 f =: /@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.) f 'im codegolfing all day long' 0 f '/@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.)' NB. no -3 bonus :( 0 ``` [Answer] # Racket, 119 ``` (define(f t)(for/and([s(map ~a'(abc def ghi jkl mno pqrs tuv wxyz))][i s][j s])(not(regexp-match(format"~a~a"i j)t)))) ``` Ungolfed (combinatoric regexing): ``` (define(f t) (for/and([s (map ~a '(abc def ghi jkl mno pqrs tuv wxyz))] [i s] [j s]) (not (regexp-match (format "~a~a" i j) t)))) ``` [Answer] # JavaScript - 152 Not a winner but I gave it a shot. Beats @Lozzaaa by 4 bytes as of posting time :) ``` function m(a){c="abc-def-ghi-jkl-mno-pqrstuv-wxyz";j=a.split("");for(z in j)if(j[z]=Math.floor(c.indexOf(j[z])/4),0!=z&&j[z-1]==j[z])return 0;return 1}; ``` [Passes all the tests.](http://jsfiddle.net/jqqhso5o/) Takes advantage of JS's lack of typing to make a multi type array, and it takes advantage of indexOf returning -1 for space support. Usage: ``` m("string here") ``` Assumes lowercase alphabetic characters and spaces only. Returns 1 for true, 0 for false. Maybe if I knew ES6 I could try the second challenge... [Answer] ## ES6, JavaScript ~~89~~ 70 characters I know its not a winner because when coming to handy operations like getting ASCII value of character, JS puts a lot of bloat (`.charCodeAt()`). ``` N=s=>[...s].every(c=>l-(l=(c.charCodeAt()-(c>"r")-(c>"y")-1)/3\|0),l=1) ``` Run it in Web Console of latest Firefox. Usage: ``` N("testing if this works") ``` The function returns either true or false. EDIT*: Golfed a lot using the `[...x].every` trick learned from @edc65 (Thanks!) I will try to golf it more :) [Answer] # GML (Game Maker Language), 149 ``` s=argument0p=n=-1for(i=0;i<string_length(s);i++){p=n;n=string_char_at(s,i)-97;x=n>17&&n--;x=n>23&&n--‌;if(!p)x=1if(!(p/3)=!(n/3))x=0}show_message(x) ``` [Answer] # Python 3 - 152 chars Not the shortest I could go, but it'll do for now ``` k=['abc','def','ghi','jkl','mno','pqrs','tuv','wxyz',' '] x=input() l=2>1 for i in range(len(x)-1): for j in k: if x[i+1] in j and x[i] in j:l=1>2 print(l) ``` ]
[Question] [ Consider a string of length N, such as `Peanut Butter` with N = 13. Notice that there are N-1 pairs of neighboring characters in the string. For `Peanut Butter`, the first of the 12 pairs is `Pe`, the second is `ea`, the last is `er`. When the pairs are mostly different characters, the string has a chunky quality, e.g. `chUnky`. When these pairs are mostly the same character, the string has a smooth quality, e.g. `sssmmsss`. Define the chunkiness of a string to be the ratio of the number of pairs with two different characters to the total number of pairs (N-1). Define the smoothness of a string to be the ratio of the number of pairs with two identical characters to the total number of pairs (N-1). For example, `Peanut Butter` only has one pair with identical characters (`tt`), so its smoothness is 1/12 or 0.0833 and its chunkiness is 11/12 or 0.9167. Empty strings and strings with only one character are defined to be 100% smooth and 0% chunky. ## Challenge Write a program that takes in a string of arbitrary length and outputs either its chunkiness or smoothness ratio as a floating point value. * Take input via stdin or the command line, or you may write a function that takes a string. * You can assume the input string only contains [printable ASCII](https://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters) characters (and hence is single-line). * Print the float to stdout to 4 or more decimal places, or you can choose to return it if you wrote a function. Decimal places that convey no information are not required, e.g. `0` is fine instead of `0.0000`. * Choose chunkiness or smoothness as you prefer. Just be sure to say which one your program outputs. The shortest code in bytes wins. ## Examples `Peanut Butter` → Chunkiness: `0.91666666666`, Smoothness: `0.08333333333` `chUnky` → Chunkiness: `1.0`, Smoothness: `0.0` `sssmmsss` → Chunkiness: `0.28571428571`, Smoothness: `0.71428571428` `999` → Chunkiness: `0.0`, Smoothness: `1.0` `AA` → Chunkiness: `0.0`, Smoothness: `1.0` `Aa` → Chunkiness: `1.0`, Smoothness: `0.0` `!` → Chunkiness: `0.0`, Smoothness: `1.0` [empty string] → Chunkiness: `0.0`, Smoothness: `1.0` Bonus question: Which do you prefer[,](https://goo.gl/UcVvMN) chunky or smooth strings[?](https://chat.stackexchange.com/transcript/message/22752050#22752050) [Answer] # CJam, 19 bytes ``` q_1>_@.=:!1b\,d/4mO ``` 100% chunky source code that calculates chunkiness. [Try this chunky goodness online.](http://cjam.aditsu.net/#code=q_1%3E_%40.%3D%3A!1b%5C%2Cd%2F4mO&input=Peanut%20Butter) ### How it works ``` q_ e# Read from STDIN and push a copy. 1>_ e# Discard the first character and push a copy. @ e# Rotate the original on top. .= e# Vectorized comparison (1 if equal, 0 if not). :! e# Mapped logical NOT (0 if equal, 1 if not). 1b e# Base 1 conversion (sum). \, e# Swap with the shortened string and push its length. d/ e# Cast to double and divide. 4mO e# Round to four decimal places. ``` Obviously, NaN rounded to 4 decimal places is 0. [Answer] # Pyth, ~~13~~ 12 bytes ``` csJnVztz\|lJ1 ``` Fully chunky code calculating chunkiness. [Demonstration.](https://pyth.herokuapp.com/?code=csJnVztz%7ClJ1&input=sssmmsss&debug=0) [Test harness.](https://pyth.herokuapp.com/?code=FN%2Bz.z%3DzPhcN%5C%E2%86%92%2B%2BzdcsJnVztz%7ClJ1&input=Peanut+Butter+%E2%86%92+Chunkiness%3A+0.91666666666%2C+Smoothness%3A+0.08333333333%0AchUnky+%E2%86%92+Chunkiness%3A+1.0%2C+Smoothness%3A+0.0%0Asssmmsss+%E2%86%92+Chunkiness%3A+0.28571428571%2C+Smoothness%3A+0.71428571428%0A999+%E2%86%92+Chunkiness%3A+0.0%2C+Smoothness%3A+1.0%0AAA+%E2%86%92+Chunkiness%3A+0.0%2C+Smoothness%3A+1.0%0AAa+%E2%86%92+Chunkiness%3A+1.0%2C+Smoothness%3A+0.0%0A!+%E2%86%92+Chunkiness%3A+0.0%2C+Smoothness%3A+1.0%0A+%E2%86%92+Chunkiness%3A+0.0%2C+Smoothness%3A+1.0%0AcsJnM.%3Az2%7ClJ1+&debug=0) ``` csJnVztz\|lJ1 Implicit: z = input() nV n, !=, vectorized over z z tz z[:-1] V implitly truncates. J Store it in J. s sum J c floating point divided by \| logical or lJ len(J) 1 1 ``` [Answer] # TI-BASIC, 46 bytes ``` Input Str1 If 2≤length(Str1 mean(seq(sub(Str1,X,1)=sub(Str1,X-1,1),X,2,length(Str1 Ans ``` `sub(x1,x2,x3` gives the substring of string `x1` starting (one-based) at number `x2` and ending at number `x3`, then `seq(` builds a sequence. Gives the smoothness value. The `Ans` variable is `0` by default, so we don't need an `Else` to the `If` statement, or to store anything to `Ans` beforehand. [Answer] # APL, 10 bytes This reads input from stdin and prints the chunkiness to stdout. The algorithm is the same one used for the J solution. ``` (+/÷⍴)2≠/⍞ ``` [Answer] ## Matlab (~~37~~ 36 bytes) This can be done with the following anonymous function, which returns chunkiness: ``` f=@(x)nnz(diff(x))/max(numel(x)-1,1) ``` Comments: * In old Matlab versions (such as R2010b) you need `+` to cast the char array `x` to a double array: ``` f=@(x)nnz(diff(+x))/max(numel(x)-1,1)` ``` But that's not the case in recent versions (tested in R2014b), which saves one byte. Thanks to Jonas for his comment. * The expression with `max` handles the one-character and zero-character cases (for chunkiness) Example: ``` >> f=@(x)nnz(diff(x))/max(numel(x)-1,1) f = @(x)nnz(diff(x))/max(numel(x)-1,1) >> f('Peanut Butter') ans = 0.9167 ``` [Answer] # [><>](http://esolangs.org/wiki/Fish), ~~40~~ 36 bytes ``` 00ii:0(?v:@=1$-{+{1+}}20. ~:0=+,n;>~ ``` This program returns the chunkiness of a string. ## Explanation ``` 00i Push 0 (# unequal pairs), 0 (length of string - 1) and read first char [main loop] i Read a char :0(?v If we've hit EOF, go down a row :@=1$- Check (new char != previous char) {+ Add to unequal pairs count {1+ Increment length by 1 }}20. Continue loop [output] ~~ Pop last two chars (top one will be -1 for EOF) :0=+ Add 1 to length if zero (to prevent division by zero errors) , Divide, giving chunkiness n; Output and halt ``` --- ## Previous submission (37 + 3 = 40 bytes) ``` l1)?v1n; n,$&\l1-}0& \; l2(?^$:@=&+&> ``` This program returns the smoothness of a string. Input is via the `-s` flag, e.g. ``` py -3 fish.py chunkiness.fish -s "Peanut Butter" ``` [Answer] ## C#, ~~94~~ 89 bytes Sub 100 bytes, so I guess that's some form of victory in itself? This is a function definition (allowed as per the spec) which returns the smoothness of the input string: ``` Func<string,float>(s=>s.Length>1?s.Zip(s.Skip(1),(a,b)=>a==b?1f:0).Sum()/(s.Length-1):1); ``` Pretty straightforward, if the length is 0 or 1 it returns 1, otherwise it compares the string to itself less the first character, then returns the number of identical pairs divided by the number of pairs. Edit - replaced Substring with Skip. Rookie mistake! [Answer] ## J, ~~14~~ 13 bytes Computes the chunkiness. Kudos to J for defining `0 % 0` to be equal to 0. ``` (]+/%#)2~:/\] ``` [Try it online](https://tio.run/##y/r/P81WT0EjVltfVVnTqM5KPyb2f2pyRn6NlUZhaX5JqnWapppdopVOcmmJj5tCcUlKZp6C4X@ugNTEvNISBafSkpLUIq7kjNC87Equ4uLi3FwgwWVpacnl6MjlmMilCAA "J – Try It Online") Here is an explanation: ``` NB. sample input in =. 'sssmmsss' NB. all infixes of length 2 2 ]\ in ss ss sm mm ms ss ss NB. are the parts of the infix different? 2 ~:/\ in 0 0 1 0 1 0 0 NB. sum and item count of the previous result (+/ , #) 2 ~:/\ in 2 7 NB. arithmetic mean: chunkiness (+/ % #) 2 ~:/\ in 0.285714 NB. as a tacit verb (] +/ % #) 2 ~:/\ ] NB. 0 divided by 0 is 0 in J 0 % 0 0 ``` [Answer] ## CJam, 23 bytes ``` q_,Y<SS+@?2ew_::=:+\,d/ ``` Explanation: ``` q e# read input _, e# its length Y< e# is less than 2? SS+ e# then a smooth string @? e# otherwise the input 2ew e# pairs of consecutive characters _::= e# map to 1 if equal, 0 if not :+ e# sum (number of equal pairs) \, e# total number of pairs d/ e# divide ``` This outputs the smoothness ratio. [Answer] # CJam, 16 bytes ``` 1q2ew::=_:+\,d/* ``` Cheaty source code that calculates smoothness. For inputs of length 0 or 1, this prints the correct result before exiting with an error. With the Java interpreter, error output goes to STDERR ([as it should](http://meta.codegolf.stackexchange.com/a/4781)). If you [try the code online](http://cjam.aditsu.net/#code=1q2ew%3A%3A%3D_%3A%2B%5C%2Cd%2F&input=!), just ignore everything but the last line of output. ### How it works ``` 1q e# Push a 1 and read from STDIN. 2ew e# Push the overlapping slices of length 2. e# This will throw an error for strings of length 0 or 1, e# so the stack (1) is printed and the program finishes. ::= e# Twofold vectorized comparision. _:+ e# Push a copy and add the Booleans. \, e# Swap with the original and compute its length. d/ e# Cast to double and divide. e# Multiply with the 1 on the bottom of the stack. ``` [Answer] # Julia, 52 bytes Smoothness! ``` s->(n=length(s))<2?1:mean([s[i]==s[i+1]for i=1:n-1]) ``` This creates an unnamed function that accepts a string and returns a numeric value. If the length of the input is less than 2, the smoothness is 1, otherwise we calculate the proportion of identical adjacent characters by taking the mean of an array of logicals. [Answer] # Nim, ~~105~~ ~~96~~ 91 bytes ``` proc f(s):any= var a=0;for i,c in s[.. ^2]:a+=int(s[i+1]!=c) a.float/max(s.len-1,1).float ``` Trying to learn Nim. This calculates the chunkiness of a string. (~~If I try to read this as Python the indentation looks all messed up...~~ Now it looks more like Ruby...) [Answer] # Python 3, 63 Bytes This is an anonymous lambda function which takes a string as the argument, and returns it's chunkiness. ``` lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(n) ``` To use it, give it a name and call it. ``` f=lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(n) f("Peanut Butter") -> 0.08333333333333333 f("!") -> 0 f("") -> -0.0 ``` [Answer] # Python 3, 52 bytes ``` lambda s:sum(map(str.__ne__,s,s[1:]))/(len(s)-1or 1) ``` This calculates chunkiness, and outputs `-0.0` for the empty string. If don't like negative zeroes you can always fix that with an extra byte: ``` lambda s:sum(map(str.__ne__,s,s[1:]))/max(len(s)-1,1) ``` [Answer] # Haskell, 64 bytes ``` f[]=1 f[_]=1 f x=sum[1\|(a,b)<-zip=<<tail$x,a==b]/(sum(x>>[1])-1) ``` Outputs smoothness. e.g. `f "Peanut Butter"` -> `8.333333333333333e-2`. How it works: ``` f[]=1 -- special case: empty list f[_]=1 -- special case: one element list f x= -- x has at least two elements (a,b)<-zip=<<tail$x -- for every pair (a,b), drawn from zipping x with the tail of itself ,a==b -- where a equals b [1\| ] -- take a 1 sum -- and sum it / -- divide by (x>>[1]) -- map each element of x to 1 sum -- sum it -1 -- and subtract 1 ``` `sum(x>>[1])` is the length of x, but because Haskell's strong type system requires to feed fractionals to `/`, I can't use `length` which returns integers. Converting integers to fractionals via `fromInteger$length x` is far too long. [Answer] ## JavaScript (ES6), 55 bytes ### Smoothness, 56 bytes ``` f=x=>(z=x.match(/(.)(?=\1)/g))?z.length/--x.length:+!x[1] ``` ### Chunkiness, 55 bytes ``` f=x=>(z=x.match(/(.)(?!\1)/g))&&--z.length/--x.length\|\|0 ``` ### Demo Calculates smoothness, as that is what I prefer. Only works in Firefox for now, as it is ES6. ``` f=x=>(z=x.match(/(.)(?=\1)/g))?z.length/--x.length:+!x[1] O.innerHTML += f('Peanut Butter') + '\n'; O.innerHTML += f('chUnky') + '\n'; O.innerHTML += f('sssmmsss') + '\n'; O.innerHTML += f('999') + '\n'; O.innerHTML += f('AA') + '\n'; O.innerHTML += f('Aa') + '\n'; O.innerHTML += f('!') + '\n'; O.innerHTML += f('') + '\n'; ``` ``` <pre id=O></pre> ``` [Answer] # KDB(Q), 30 Returns smoothness. ``` {1^sum[x]%count x:1_(=':)(),x} ``` # Explanation ``` (),x / ensure input is always list x:1_(=':) / check equalness to prev char and reassign to x sum[x]%count / sum equalness divide by count N-1 1^ / fill null with 1 since empty/single char will result in null { } / lamdba ``` # Test ``` q){1^sum[x]%count x}1_(=':)(),x}"Peanut Butter" 0.08333333 q){1^sum[x]%count x:1_(=':)(),x}"sssmmsss" 0.7142857 q){1^sum[x]%count x:1_(=':)(),x}"Aa" 0f q){1^sum[x]%count x:1_(=':)(),x}"aa" 1f q){1^sum[x]%count x:1_(=':)(),x}"chUnky" 0f q){1^sum[x]%count x:1_(=':)(),x}"!" 1f q){1^sum[x]%count x:1_(=':)(),x}"" 1f ``` [Answer] # [Ruby](https://www.ruby-lang.org/), ~~69~~ 66 bytes ``` ->s{(c=s.chars.each_cons(2).count{\|x,y\|x!=y}.to_f/~-s.size)>0?c:0} ``` [Try it online!](https://tio.run/##FY1BC4IwGEDv@xVLAxVySUdhdu3YPUJ0TBRsE79vsDXXT2/Z4b3je6vpXRx4LBvwueDAxNitwGQnxlZoBfmlYEIbhX6zJ7fZA3eBoW6H86cEBtNbFk11FXUVoqWcHts9oF8LWQwCTbLU25DVNPXDwz5DEu@yUwZpbxDlSm5ynvVu98cR8tULTvs0luoH "Ruby – Try It Online") Shaved of a few bytes with comments from IMP. Also, with the upcoming version 2.7.0 of Ruby it's possible to save some bytes by replacing `\|x,y\|x!=y` with `@1!=@2` [Answer] # Python 3, 69 bytes No one has posted a Python solution yet, so here's a fairly straightforward implementation of a "chunkiness" function. It short-circuits on a string of length `1`, and prints `0` (which is an integer rather than a float but seems to be allowed according to the rules). On an empty string, it outputs `-0.0` rather than `0.0`. Arguably this is could be considered acceptable, as `-0.0 == 0 == 0.0` returns `True`. ``` def c(s):l=len(s)-1;return l and sum(s[i]!=s[i+1]for i in range(l))/l ``` Examples: ``` >>> c(''); c('a'); c('aaa'); c("Peanut Butter") -0.0 0 0.0 0.916666666667 >>> -0.0 == 0 == 0.0 True ``` (Python 3 is used for its default float division.) [Answer] # C, 83 bytes ``` float f(chars){int a=0,b=0;if(s)while(s[++a])b+=s[a]!=s[a-1];return--a?1.b/a:b;} ``` A function returning chunkiness. ### Explanation ``` float f(char s) { ``` Accept a C string, and return a float (double would work but is more chars). ``` int a=0, b=0; ``` Counters - `a` for total pairs, `b` for non-matching pairs. Using `int` limits the "arbitrary length" of the string, but that's only a minor violation of the requirements and I'm not going to fix it. ``` if (s) ``` Special case the empty string - leave both counters zero. ``` while (s[++a]) ``` Non-empty string - iterate through it with pre-increment (so first time through the loop, `s[a]` will be the second character. If the string has only one character, the loop body will not be entered, and `a` will be 1. ``` b += s[a]!=s[a-1]; ``` If the current character differs from the previous, increment `b`. ``` return --a ? 1.b/a : b; } ``` After the loop, there are three possibilities: 'a==0,b==0' for an empty input, 'a==1,b==0' for a single-character input or 'a>1,b>=0' for multi-character input. We subtract 1 from `a` (the `?` operator is a sequence point, so we're safe), and if it's zero, we have the second case, so should return zero. Otherwise, `b/a` is what we want, but we must promote `b` to a floating-point type first or we'll get integer division. For an empty string, we'll end up with a negative zero, but the rules don't disallow that. ### Tests: ``` #include <stdio.h> int main(int argc, char *argv) { while (++argv) printf("%.6f %s\n", f(argv), argv); } ``` Which gives: ``` ./chunky 'Peanut Butter' chUnky sssmmsss 999 AA Aa '!' '' 0.916667 Peanut Butter 1.000000 chUnky 0.285714 sssmmsss 0.000000 999 0.000000 AA 1.000000 Aa 0.000000 ! -0.000000 ``` as required. [Answer] # Perl, 69 Function returning smoothness: ``` sub f{($_)=@_;$s=s/(.)(?!\1)//sgr;chop;!$_\|\|length($s)/length;} ``` ### Explanation ``` sub f { # read argument into $_ ($_) = @_; # copy $_ to $s, removing any char not followed by itself # /s to handle newlines as all other characters $s = s/(.)(?!\1)//sgr; # reduce length by one (unless empty) chop; # $_ is empty (false) if length was 0 or 1 # return 1 in that case, else number of pairs / new length !$_ \|\| length($s)/length; } ``` ### Tests ``` printf "%.6f %s\n", f($a=$_), $a foreach (@ARGV); 0.083333 Peanut Butter 0.000000 chUnky 0.714286 sssmmsss 1.000000 999 1.000000 AA 0.000000 Aa 1.000000 ! 1.000000 ``` [Answer] # Ruby, 63 Bytes Outputs chunkiness. `f=->s{s.chars.each_cons(2).count{\|x,y\|x!=y}/[s.size-1.0,1].max}` Similar to @daniero's solution, but slightly shortened by directly dividing by the string length - 1 and then relying on .count to be zero with length 0 & 1 strings (the .max ensures I won't divide by 0 or -1). [Answer] ## Mathematica, ~~73~~ 72 bytes This doesn't win anything for size, but it's straightforward: Smoothness ``` N@Count[Differences@#,_Plus]/(Length@#-1)&@StringSplit[#,""]& In[177]:= N@Count[Differences@#,_Plus]/(Length@#-1)&@StringSplit[#,""] &@"sssmmsss" Out[177]= 0.285714 ``` [Answer] # GeL: ~~76~~ 73 characters Smoothness. ``` @set{d;0} ?\P$1=@incr{d} ?= \Z=@lua{c=@column -1\;return c<1and 1or $d/c} ``` Sample run: ``` bash-4.3$ for i in 'Peanut Butter' 'chUnky' 'sssmmsss' '999' 'AA' 'Aa' '!' ''; do > echo -n "$i -> " > echo -n "$i" \| gel -f smooth.gel > echo > done Peanut Butter -> 0.083333333333333 chUnky -> 0 sssmmsss -> 0.71428571428571 999 -> 1 AA -> 1 Aa -> 0 ! -> 1 -> 1 ``` (GeL = Gema + Lua bindings. Much better, but still far from winning.) # Gema: ~~123~~ 120 characters Smoothness. ``` @set{d;0} ?\P$1=@incr{d} ?= \Z=@subst{\?\=\?.\;@cmpn{@column;1;10;10;@fill-right{00000;@div{$d0000;@sub{@column;1}}}}} ``` Sample run: ``` bash-4.3$ for i in 'Peanut Butter' 'chUnky' 'sssmmsss' '999' 'AA' 'Aa' '!' ''; do > echo -n "$i -> " > echo -n "$i" \| gema -f smooth.gema > echo > done Peanut Butter -> 0.0833 chUnky -> 0.0000 sssmmsss -> 0.7142 999 -> 1.0000 AA -> 1.0000 Aa -> 0.0000 ! -> 1.0 -> 1.0 ``` (Was more an exercise for myself to see what are the chances to solve it in a language without floating point number support and generally painful arithmetic support. The 2nd line, especially the `\P` sequence, is pure magic, the last line is real torture.) [Answer] # Java 8, ~~84~~ 82 bytes ``` s->{float l=s.length()-1,S=s.split("(.)(?=\\1)").length-1;return l<1?1:S<1?0:S/l;} ``` Outputs Smoothness. [Try it online.](https://tio.run/##lZPfT8IwEMff/SvOPbWRlRUxCgMJJj5qTBaf1IfSFRiUblk7IjH87Vj2gzBgJjZdk2t7n/v2drdga@YuwuWOS6Y1vLBI/VwBRMqIdMq4gNe9CTCVMTPAUWDSSM1AY99ub@1npzbMRBxeQcEQdtp9/Cluy6EmUqiZmSPs0lZgTZ3IyCAHEYxGw89Pih1cXnGpnwqTpQrkgI5oP7Cr1w/a0t/u/CJOkk2kjVOGW8dRCCurt9T08cVwodUIbWO8CaYyA0@ZsU9xsG8P2m14/k4ENyLsg0e8h1tCCCAKCYvSFtAOqFi5e0PjIxKfv6vlpkCUo06qdpGXk3QL7i6TtNarlV2OWCea7mk313RXkRo09Xq9mqBTEj1o6lQk7zJpPD4FNZGqPDWB2N@gC2miB9Ix6PqM06SoKB0YAD32P3f/nz/bj4kdnPMwFHtcw1@i3eol3XpO6p2Rl2rOPrRPUanBRhuxInFmSGIPDCr6yrZbnCJr11rIv7mRg47n4zMvB5zS7/RIKqQIt9iyX7e7Xw) Explanation: ``` s->{ // Method with String parameter and float return-type float l=s.length()-1, // Length of the input-String minus 1 (amount of pairs in total) S=s.split("(.)(?=\\1)").length-1; // Length of the input split by duplicated pairs (with lookahead) return l<1? // If the length of the input is either 0 or 1: 1 // Return 1 :S<1? // Else-if `S` is -1 or 0: 0 // Return 0 : // Else: S/l;} // Return duplicated pairs divided by the length-1 ``` [Answer] # [Coconut](http://coconut-lang.org/), 38 bytes ``` s->sum(map((!=),s,s[1:]))/-~len(s[2:]) ``` [Try it online!](https://tio.run/##RY5BCsIwEEWvkgahE2iUii5SaKGewI2r6qKUBEWTlkwKlVqvHpNu3Lz5D2aY3/Vdb0bnVXn1yCscNeh2AEhKlmGGTV7cGNvx70sawGYfzAM9yzbckNPonLQ0I7S7X8zzHRMiah0QsxAijrpe2UYmEZSRT0XCmw1MhFdEpfOU2CI/LtFmBRMrtge1pP@9wT6MWzXUDSWl/wE "Coconut – Try It Online") A Python 3 port would be [50 bytes](https://tio.run/##Hce9DoIwFIbh3as4sNAmgMGfgSaa4BW4OKEhVdtApIX0HAZC8NaRujzf@/Uj1Z3dL/p0X1ppnm8JKHAwzMieIbm0qqyqqhhjLDPx4HybfFtlGZa79S26c0DQWGDhVUk7EFwGIuXCGMJXfbOf0RciGrPiO89zP0XxV3oDT8jFBqB3jSWmo4kCJ7LjDMkZJs2Ii/Sg54gvPw). [Answer] ## PowerShell, 55 bytes Smoothness ``` %{$s=$_;@([char[]]$s\|?{$_-eq$a;$a=$_;$i++}).count/--$i} ``` Seems a little bit silly to get a variable in stdin and then give it an identifier, but its quicker than having a function. [Answer] # Python 3, 61 Bytes calculate chunkiness: ``` f=lambda s: sum(a!=b for a,b in zip(s,s[1:]))/max(len(s)-1,1) ``` [Answer] # K (22) tweaked WooiKent's Q solution: ``` {1^(+/x)%#x:1_=':(),x} ``` [Answer] # Mathematica, 107 bytes Calculates chunkiness by taking half of the Levenshtein distance between each digraph and its reverse. ``` f[s_]:=.5EditDistance@@{#,StringReverse@#}&/@StringCases[s,_~Repeated~{2},Overlaps->All]//Total@#/Length[#]& ``` If you'd prefer an exact rational answer, delete `.5` and place a `/2` before the last `&` for no penalty. The program itself has chunkiness 103/106, or about .972. ]
[Question] [ With challenges like [Output with the same length as the code](https://codegolf.stackexchange.com/questions/121056/output-with-the-same-length-as-the-code) and [Create output twice the length of the code](https://codegolf.stackexchange.com/questions/59436/create-output-twice-the-length-of-the-code/), I thought of a separate, but similar challenge. The task is to produce an output. It can either be a string, a list of characters, or whatever is the default output format of your program. However, your output must always be the same length, regardless of the input. And more importantly, the output should be different for different inputs. ## Input A single integer \$n\$, the ranges of which is determined by the choice of language. If your language has variable length integers, the range is \$-2^{31} \leq n < 2^{31}\$. ## Output A string or a list of characters, or a print to STDOUT or STDERR. You may only use one of these methods. The output should be of the same length regardless of the input, but it is up to you to define which length that is. The output may not contain the digit characters `0-9`, or the minus sign `-`. The output should be deterministic. You should be able to prove that for every output there is only one possible input, either by a formal proof, an argument, or a brute-force search. This is a code golf question, so shave off any extraneous bytes. All languages are welcome, the more the better! [Answer] # JavaScript (ES8), 33 bytes Expects the input in the range of [safe](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER) JS integers: \$-2^{53}\le n < 2^{53}\$. Returns a string of 76 characters. ``` n=>btoa(n.toString(2)).padEnd(76) ``` [Try it online!](https://tio.run/##dY7fa8IwEMff81ccvjSHTbCtOkFacBBlg3Ww7mEwhqQ/oh2aSNIK@@trnAOf9nLHfb53x@dbnqWrbHvqmDZ1M6h00GlWdkZSzTtTdLbVOxoj8pOsha7pwxyHawwpOEgzeOyVaixX1hypgzEEAd7vglK6Zj4NkJDlJ4tDYFEIkxB89UMUJ1cSJ9NZCHl/LP2fl9XHtlitxfYpfxcb8eYX/kmAQfRFuDJWyGpPtZchAJXRzhwafjA76tnN5089WqAHI5bByPfn4jXn7tezVT9UUY2IBIcL "JavaScript (Node.js) – Try It Online") ## How? ### Step 1 The input is first converted to binary. This preserves the leading minus sign for negative numbers. Examples: * `123` → `"1111011"` * `-77` → `"-1001101"` ### Step 2 The resulting string is encoded in base-64. It means that each block of 1 to 3 characters will be turned into a new block of 4 characters. This conversion is safe because none of the resulting blocks contain the forbidden symbols (digits or minus sign). 3-character blocks ``` "-10" -> "LTEw" \| "011" -> "MDEx" "-11" -> "LTEx" \| "100" -> "MTAw" "000" -> "MDAw" \| "101" -> "MTAx" "001" -> "MDAx" \| "110" -> "MTEw" "010" -> "MDEw" \| "111" -> "MTEx" ``` A single final block of 1 or 2 characters has to be encoded if the length of the binary string is not a multiple of 3: 1-character blocks ``` "0" -> "MA==" \| "1" -> "MQ==" ``` 2-character blocks ``` "-1" -> "LTE=" \| "10" -> "MTA=" "00" -> "MDA=" \| "11" -> "MTE=" "01" -> "MDE=" \| ``` ### Step 3 The final output is padded with trailing spaces. [Answer] # [Python 3](https://docs.python.org/3/), ~~49~~ 39 bytes ``` lambda i:[chr(ord(x)2)for x in"%9x"%i] ``` [Try it online!](https://tio.run/##RYwxDsIwEAR7v@LKW4ugOOki8RKgMASTk4wdXVwEPm9IEdFMMdLM/C5TTn0Np0uN/nUbPclwvk/KWUdeYTuErLSSJFqKsuD4CRIjO4drnVVS4cAdWUu9A8xumr@D2Q6yHdSn54Mb17YH@gGDoT0QoH4B "Python 3 – Try It Online") -10 bytes thanks to [negative seven](https://codegolf.stackexchange.com/users/86422/negative-seven)* Converts the integer to hexadecimal, and prepends spaces up to 9 characters total. Then, doubles the ASCII code of each character in the string (some extend outside of ASCII into Unicode, but Python handles it fine), outputting a list of characters. This works because every digit, including `-`, is mapped to a different ASCII character. No integers between `-2147483648` and `2147483648` are equal, so converting them to hexadecimal and prepending spaces would not make them equal. Then, mapping them to different codepoints does not lead to collisions, so there are still no two values in the range which lead to equal outputs. # [Python 3](https://docs.python.org/3/), ~~59~~ ~~56~~ 47 bytes ``` lambda i:[map(lambda x:chr(ord(x)2),"%9x"%i)] ``` [Try it online!](https://tio.run/##RYvLCoMwEADv@YpFEHaDgo9TA35J6yGtRhdqEhYP6denHhQvAzMw8bevwffZDa/8tdt7ssDmqTcb8dRkPqtgkAkT6Y6qonykomQacxT2OzrsQGvoWyJ1lfpupFwQYGAPYv0yY902TQUHyCi4BibKfw "Python 3 – Try It Online") -3 bytes thanks to [Jitse](https://codegolf.stackexchange.com/users/87681/jitse) -9 bytes thanks to [negative seven](https://codegolf.stackexchange.com/users/86422/negative-seven) Same algorithm, but using `map` instead of a `for` loop. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~11~~ 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` тjÇ·ç ``` -6 bytes porting [@Stephen's approach](https://codegolf.stackexchange.com/a/190135/52210), so make sure to upvote him! Outputs a list of up to 100 characters, with \$100-(\text{input length})\$ amount of `@` (double the space codepoint), and all `-0123456789` mapped to `Z`bdfhjlnpr` (double the ASCII codepoints). [Try it online.](https://tio.run/##yy9OTMpM/f//YlPW4fZD2w8v//9f19AAAA) Explanation: ``` j # Prepend spaces in front of the (implicit) input-integer to make it of length: т # 100 Ç # Convert each character to its unicode value · # Double each ç # And convert it back to a character # (after which the resulting list is output implicitly) ``` --- Original 11 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) answer: ``` Ä¶×AIdè«žIj ``` [Try it online](https://tio.run/##yy9OTMpM/f//cMuhbYenO3qmHF5xaPWjppas//91DQ0A) (limited to `1000` instead of `2147483648`). Explanation: The output length is always 2,147,483,648 characters long. It will output \$2147483648-\|n\|-1\$ amount of spaces, appended with \$\|n\|\$ amount of newlines, appended with either an 'a' if \$n\lt0\$ or 'b' if \$n\geq0\$. ``` Ä # Get the absolute value of the (implicit) input-integer ¶× # And have a string with that many newline characters A # Push the lowercase alphabet Id # Check if the input is non-negative (>=0) (1 if truthy; 0 if falsey) è # Use that to index into the alphabet (so "a" for <0 and "b" for >=0) « # Append that to the newline-string we created earlier j # And prepend spaces to make the string of a length: žI # 2147483648 (this has been replaced with `₄`/1000 in the TIO) # (after which the result is output implicitly) ``` [Answer] # [brainfuck](https://github.com/TryItOnline/brainfuck), ~~48~~ ~~29~~ ~~28~~ ~~16~~ 13 bytes This program requires cells, where \$ c\_n \in \mathbb{N} \$, but if you want consistent results, make sure that \$ c\_n < 256 \$ Output will obviously be unique no matter what number will you enter (\$ -\infty \lt n \lt \infty \$). If the integer is shorter, the program will pad out the output to match exactly \$ \infty \$ bytes, so the length is always the same. This answer is a bit loopholing the challenge, as it didn't state that output has to be finite. ``` +[,[->-<]>.+] ``` [Try it online!](https://tio.run/##SypKzMxLK03O/v9fO1onWtdO1ybWTk879v9/XUMjYxNTM3MLSzjDYKSJAQA "brainfuck – Try It Online") --- Original, 28 byte answer: ``` ->,[[->-<]>.[-]<<->,]<[<.>-] ``` This one will pad the output to be exactly \$ 2^8 - 1 \$ bytes. The number conversion mechanism works the same here. This program assumes the same as the program above. [Answer] # [Python 3](https://docs.python.org/3/), 39 bytes ``` lambda n:f"{n:33b}".translate("abc"99) ``` [Try it online!](https://tio.run/##VY3LDoIwEEXX8hWTrlpEAtQXJHwJElOgaA0U0o4LY/x2bHVhXExOcmbu3PmB10nzpS9PyyDGphOgi548dcF58yIxGqHtIFBSIpqWhHnOFjXOk0Fwm24aA5QWz62w0kIJVRJBGsHGTxaG3PEDL9KMb3f7wzFPalhD9Y3HHkoj/Ttn0E8GFCjtWy6SZgmrg8BL9PLXWQSr2fi8RUORxeZ2t0hT94gAYRH0TrLlDQ "Python 3 – Try It Online") Turns the given number into a binary string representation (padded with spaces), then maps the characters `(space)-01` to `caab` with the [`str.translate`](https://docs.python.org/3/library/stdtypes.html?highlight=translate#str.translate) function. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` œ?ØẠ ``` A monadic Link accepting an integer which yields a list of 52 characters. The input range may be up to somewhat more than \$-2^{223} \leq n \lt 2^{223}\$ since \$52!>2^{224}\$. [Try it online!](https://tio.run/##y0rNyan8///oZPvDMx7uWvD//39dI0MTcxMLYzMTCwA "Jelly – Try It Online")* ### How? ``` œ?ØẠ - Link: integer, n ØẠ - alphabet (Jelly's longest built-in character list containing no digits - or hyphen) = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" œ? - permutation at index (n) if all 52! permutations were written out - in lexicographical order. - This indexing is modular so when n = -x we fetch the (52!-x)th entry. ``` So... ``` -2147483648 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFEHB -2147483647 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFHBE -2147483646 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFHEB -2147483645 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKHBEF ... -4 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDACB -3 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDBAC -2 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDBCA -1 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCAB 0 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA 1 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz 2 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxzy 3 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz 4 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyzx ... 2147483644 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsvyu 2147483645 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsyuv 2147483646 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsyvu 2147483647 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpusvy ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), 38 bytes ``` f(a,i){for(i=32;i--;putchar(a>>i&1));} ``` [Try it online!](https://tio.run/##S9ZNT07@r5yZl5xTmpKqYFNckpKZr5dhx4UQysnMzSwpBor9T9NI1MnUrE7LL9LItDU2ss7U1bUuKC1Jzkgs0ki0s8tUM9TUtK79n5lXopCbmJmnoalQzcWZpmGgaa0AATDF6jF56prWIDlDPHJGeOQ8/ULifR0jgCpwyHn6YZXThVuIJlf7HwA "C (gcc) – Try It Online") This expands each bit of the input integer into a byte that is either 0 or 1 (which are both unprintable characters, but there is no rule against that). So the output is always 32 bytes, and guaranteed to be unique. [Answer] # [Ruby](https://www.ruby-lang.org/), 27 bytes ``` ->n{('%34b'%n).tr'01','ah'} ``` [Try it online!](https://tio.run/##KypNqvyfZvtf1y6vWkNd1dgkSV01T1OvpEjdwFBdRz0xQ732f7SxiaGOLogwszAxN7M0MTXRMdLSMgYKgqlYvdzEguqazBqFAoW06MzY2v8A "Ruby – Try It Online") `('%34b'%n)` Converts an integer into its binary representation, using `..1` to indicate a negative number (this is meant to represent an infinitely-long prefix of 1s), and left-pads this out to 34 characters using spaces. Then we replace the `0`s with 'a' and the `1`s with 'h' to create the Maniacal Base 2 Representation: strings like "haaahahahaaha" prepended with spaces and sometimes `..`. Since every step here is invertible this is 1:1. Edit: Let the record show that @manatwork posted this identical solution first. Oops. I should've refreshed. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes ``` Ø%+ṃØA ``` [Try it online!](https://tio.run/##y0rNyan8///wDFXthzubD89w/G/9qGGOgq6dwqOGudaH28E8jZzUvPSSDKiQjwpQcK4ml5GWsaGftcrR3YfbHzWtifwPAA "Jelly – Try It Online") Since Jelly has arbitrary length integers, this monadic link takes an integer in the range \$±2^{31}\$ and returns a length 7 alphabetic string. It works by adding \$2^{32}\$ and then base decompressing into the capital letters. [Answer] ## Haskell, 31 bytes ``` map(\d->[d..]!!10).show.(+2^60) ``` [Try it online!](https://tio.run/##y0gszk7NyfmfZhvzPzexQCMmRdcuOkVPL1ZR0dBAU684I79cT0PbKM7MQBMon5mnYKuQks@loFBQWhJcUuSTp6CikKZgaGCARQirmMH/f8lpOYnpxf91kwsKAA "Haskell – Try It Online") Adds `2^60` to the input so that the resulting number has the same amount of digits for the whole input range. Turn into a string and shift each character 10 places to the right in the ASCII order (`0` -> `:` ... `9` -> `C`). [Answer] # [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 35 bytes ``` x=>$"{x,11}".Select(n=>(char)(n+n)) ``` [Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpdsk5lXouPpmleam1qUmJSTapOckVhkZ5dm@7/C1k5FqbpCx9CwVkkvODUnNblEI8/WTgOkQFMjTztPU/O/NVdAEdAAjTQNQ01NBMcSmaOLIgUk9XwTK8ISc0pTMcQz82Di/wE "C# (Visual C# Interactive Compiler) – Try It Online") [Answer] # [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 52 bytes ``` x=>(new char[32]).Select(y=>(char)(x%2+65+(x/=2)0)) ``` [Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpdsk5lXoqPg6ZpXmptalJiUk2qTnJFYZGeXZvu/wtZOIy@1XAEkEG1sFKupF5yak5pcolEJlAAJampUqBppm5lqa1To2xppahloav635gooAhqpkaZhaGSoqYng6loaGKAIGBobmwP5/wE "C# (Visual C# Interactive Compiler) – Try It Online") Different approach to a c# solution, takes advantage of the fact that c# modulus is negative for negative numbers. I suppose you could shave off a byte or two if you allow non-display characters ('\0', and so on) by updating the `+65...` to not offset the character value to something human readable. [Answer] # [Perl 5](https://www.perl.org/) `-MDigest::MD5=md5_hex -p`, 23 bytes ``` $_=md5_hex$_;y/0-9/k-t/ ``` [Try it online!](https://tio.run/##K0gtyjH9/18l3jY3xTQ@I7VCJd66Ut9A11I/W7dE//9/Qy4jLl1DLl0jLoN/@QUlmfl5xf91fV0y01OLS6ysfF1MYfr@6xbkAAA "Perl 5 – Try It Online") Previously: ### [Perl 5](https://www.perl.org/) `-p`, 29 bytes ``` $_=sprintf'%064b',$_;y/01/ab/ ``` [Try it online!](https://tio.run/##K0gtyjH9/18l3ra4oCgzryRNXdXAzCRJXUcl3rpS38BQPzFJ//9/Qy4jLl1DLl0jLoN/@QUlmfl5xf91C3IA "Perl 5 – Try It Online") Converts the number to its 64 bit binary representation, then transliterates `0` and `1` to `a` and `b`, respectively. [Answer] # T-SQL, ~~73 70~~ 61 bytes ``` SELECT TRANSLATE(STR(n,11),'-0123456789','ABCDEFGHIJK')FROM t ``` I'm just directly replacing the digits (and `-`) with letters, after `STR` pads the integer to 11 characters. No conversion to hex or binary is necessary. [`TRANSLATE`](https://docs.microsoft.com/en-us/sql/t-sql/functions/translate-transact-sql?view=sql-server-2017) was introduced in SQL 2017. Input is via a pre-existing table \$t\$ with INT column \$n\$, [per our IO rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341). Range of the `INT` datatype in SQL is \$-2^{31} \leq n < 2^{31}\$. EDIT: Saved 3 bytes by replacing manual padding with a conversion to CHAR(11), which is a fixed-width character format that automatically pads with spaces. EDIT 2: Saved 9 bytes* by using `STR()` function instead of `CAST`. `STR` converts a number to a text string padded to the specified length. [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 28 bytes ``` {11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]} ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT/@v8ahvql/wo941mnogZrCrXqizr4t6Un6FQn6egm6aLYgssS0pSk1Vf9S1ODUvMSknNdjRJwTIAap3jlQvTswpUdfkAnI8/R@1TTD4X21o@KhtorpClHr0o96tjzqXGMTqAGUdgby@QyvUD61Xr3vUu@JR71SgbGzt/zSgJqAMRH9X86H1xkDdIKcEOQPJEA/P4P@PelelHVqh8ahnr@6j3s1GWoYGmjoaMBYA "APL (Dyalog Unicode) – Try It Online") Simple Dfn, taking an integer argument. Uses `⎕IO←0`. TIO links to a test case from `-2^10` to `2^10`. The `0~⍨` part removes the duplicate `0` from the arguments. ### How: ``` {11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]} ⍝ Dfn ⎕A[ ] ⍝ Index the Uppercase Alphabet with ⍕⍵ ⍝ String representation of the argument '¯'~⍨ ⍝ Without the character ¯ ⍎¨ ⍝ Executing each digit back into integers , ⍝ Prepend ' Z'[ ] ⍝ A character from the string ' Z' indexed by ⍵≤0 ⍝ Argument ≤ 0. Returns 1 if true, else 0. ⍝ This will prepend a whitespace to positive numbers, and a Z otherwise. 11↑ ⍝ Take the first 11 characters, padding with whitespace. ``` [Answer] # [Japt](https://github.com/ETHproductions/japt), 6 bytes I think this is right. Inspired by Stephen's Python solution so please `+1` him. ``` ¤ùI cÑ ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=pPlJIGPR&footer=aSI6ICJpTs75IGdUsA&input=WwotOTAwNzE5OTI1NDc0MDk5MgotOTAwNzE5OTI1NDc0MDk5MQotMTAsLTksLTgsLTcsLTYsLTUsLTQsLTMsLTIsLTEKMAoxLDIsMyw0LDUsNiw3LDgsOSwxMAo5MDA3MTk5MjU0NzQwOTkwCjkwMDcxOTkyNTQ3NDA5OTEKXS1tUg) ``` ¤ùI cÑ :Implicit input of integer ¤ :Convert to binary string ù :Left pad with spaces I : To length 64 c :Map codepoints Ñ : Multiply by 2 ``` [Answer] # [Malbolge](https://github.com/TryItOnline/malbolge), 2708 bytes This answer is super cheaty, because it always produces the same amount of input, which is equal to \$ \infty \$. ``` bP&A@?>=<;:9876543210/.-,+)('&%$T"!~}\|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+/.-,+)('&%$#"!~}\|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+)('&%$#"yb}\|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;\|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%k('&%e#d!~}\|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6\|\|3876w4-tr/.-&+)('&%$e"!~}\|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHGED=%%:?>=~;:{876w43210/(-,+)('h%$d"ca}\|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G(DCB%@?"=<;\|98765.3210p.-n+$)i'h%${"!~}\|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G(D'%A@?"=<}:98y6543,1r/.o,+)j'&%eez!~a\|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HGED'BA@?>7~;:{y7x5.3210q.-n+)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}\|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nlki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`\|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G(D'%A$">!};\|z8yw543t1r/(-,+)(i&%fd"!~}\|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4ussr)p-,m)ihh}$#d!awv{^\x[YuXVrUSonQlNdchKIeHFbaD_AWV[><X;988MRQ4O1GFK.,++@ED'B$:9>!};:9zy0wuut1/p-,mk#"hh}$#"cb}v{^\\[vunWrqTonmOkjMLgf_HcbE`_A]@>ZY<:VONS64P31M0.J-+G(D'%A$">!}\|\|3876wv321/p-,mk#"'hf$ec!b`\|{^y[qpuXVUUjonQOkdchKIeHFbEC_B@\?=Y<:VUT76QPONG0KJ-HGFED'%A:9!!6;:9zy654321q.-n+j(ig%fd"ca}`^]]rwvYtVlkpSQmPNMMbgfIdF\[`_^A@[ZYXWVUNS6443NMLKJIHG@)DC&A@?!=<}\|98765432+r/.-,+k#('&%e{dy~}\|uzsx[vuXsrqpoRPledLLafedGF[`C^]\?ZY;W:8T7544INM0.JCBG(''<A@#!=65:{yxx/43tr0)(-nlkk"'&ge#zy~a_^^sxwZXtmlqTRQQfkjMKg`_dcbEZ_B]\?=SRW:8T75Q42N1/KJ-+G@?D'%A$">!};\|z87x5u-,1rp.-n+k#"'hfeez!~}`_t]xwvYtsUTTinmPNjcbgJHdGEa`_BW\?ZY<WVUTS64PIH00EJIH+?(&&;@#!!~5:{87xv.-2sq/.om+$#(ig%$e"bxw\|_]y\ZvuXsUkjoRPOOdihKfH^]bEC_^A\>TS;;PUTS65JO2MLK.,BA))>CBA$9>!}}\|3z765v32r0/p-m%$)jh&ge#"c~`vuz][ZZotsVqSihmPNMMbgfIdF\[`CA@@UZY<W9ONS6433HML/J,BAF)'&&;@?"=}549zx6wutt+0/.on%l)('h%$d"ca}`^z][wvYtVlkpSQmPNjiLJf_^cFDCCX]\?=YRQV9766KPO20LEDI,))>CB%#?87<}{9zx6wu3tr0/.o&m)('&%fA/cQ>_^;]87%54"32pRA-yejih:s_GGFDDC^{i[T<XQ9b8r_5]O20Li-zBSdQPO%##]nml43V1TvS@cs0/_'JJH#jhg%BTd!xw_{t99J6$tV21SBR@?kjcbtJ%^F"DD21]@[xfw;)9Nqq5Jmm~LKWVyx@E't&%:]][~YkF8hgv.tssOMp:&ml6Fi&D1T"y?,O<^s\7vX#Wr2}\|Rzl+j<bK`r$F"4ZCk\|\?-=RQ ``` [Try it online!](https://tio.run/##tZZXj6PsEoR/iwMe53HAAeNxNs45B8A5YZzAOfz1/brBs7Mr7cW5OXdISKVS9dPVrzhcj7br@fTXr1HZEI2EQ19BOkD5fV4P6XY5HZ92m9ViNhk/DIS@rtW8ng@avV7Op6MsrRu1asV@vViWpiw1nTAjcsBzbB/@VismYx1@sqIm5chlM9cLc0oMCT4S1n4FPaq63eaymP9U1ynqR/l62KP6Yb/absSysFou5rPpZNxPJDrRaD8U6tB00@/35j1ulyv1@ZmwWlMmU8hgiOp0Gt/LE7hffZfT8Wj927tOex09H/eb6l1s7mvbhVgqgfpwNk2Pk8MBqve6nWor0PDV8rmyu1jI52wZa4pJJgwEgcl46Qd19Tk@ySMms7VtLIJJq5nP0fvlOUD17qmD3mvbqrgWVvlFDr0nhwlMJtT9areaoO6tlEtFRz6XUNXjsagOknnSpNt/xdwl5wHUDYRZQO9T3QST4W4sem9Jzf1uuymv0fs8A95Hw0GMU7zT4B1yJ8sZF3jPWq1RJmk0xOhAWPsKPu@3m9PrObklyH23sYqCabUwzEF99Bryd64P6ts2eN9VN@JMWBVy8wGfSvWHCVAP90LBNk01/N6qx10qFmCqcasFvSMzGo338XDDVM@kTT7gVA3fuU@/p6rk3loL4F0E7@PFfDCdpMA73271w5B7pVmq@6qVcgZy/8xm0tFv9ZAmSN8p//UMzEiS4t2yXhk1r9nsrh0PnwNIpnfutuVWY1@vbioloZgHZjKTMTPs8koywTYk4wciy6W0qp4yJxNfBBGAqb7owF3xrvBufDOzIPQTVH/wt/5h3@lspGZ9t62W19NJPj@cZVLjUXIQa7fC4XonGGhSMFWy7HYWHPaszZIyG2GqhMI7MKPwjuo7OzCjNy1R/a4k8yay3YRkahVMJj/6X9Q/iKii/oRtUpixAjP2LXpfITPTm@Y1fHCydOl1jpjMaonJrAqL7ICfpJL/mKoLiMzalGQ@Ypi7D5OBbVK979G7GZnBbRq/kHf2oEz1AFNdqLsK3jkkUsk91GkrRHoquE0ORZ0Jo/o79xsmc3K7JNzVzVqvMy7nxOydO4tN0Glh7pBMuYhEZtPofcDHWGQmCNtUL1Q9ZcW7HZiBJoDcdWG/7/kkqdvFez665YNjD7u6NguQ@0w/HWvQO4e5b2FXG0BkZS0UlotcZsqxyWSXj0X64a9/5A7bpBDpx458MyM5Ud1ACIL2rT4aoPd@98f7Wigu8/MZP8Fk4pzinW6hej7ndqf/mqpeG9I86ccNeSfdMkz1TeTSgMkgM7zMvht4X1c7Mo/e08woGedxqvUaThW2icxmis7PnN2atpiwCSAZpQmAyAu0mCQdTDubVTSblovFUw89MzyfsAmAmXbz0KhhMsXJ@K0OLRZtNVVm/P5CtUKWnCkG1C2WCDKjD1DoPUDdro7z8Sg7YVdBXdBpFXXtePRE9X7vdNy0Dop3JBKTSSPvfJSNhLqYe6n4D96VZN49A8z8qP/kDlPt7XfgvdGA6wG8//YOyfyeKiSjNHDqTWQS1QMUtJjiXb18ZpX31Q@RA45F3jvye1fLxUJhhD3D9HvIewQaGPsdvZPK9cCeiZjeHQm7@vi@q5aDcpsEndLv98kVO/IGuwpNgA380zPQkUzvh5mAv@7zkCR0JCQTj0EyHx/BaESn@fLi5bvAVJF3kxF4RyKx329X6HeOky7YkSIwU61UvvsdiETeQf2rVlXVK6QLmcHcI@G/iIQmONqgZ5QWU3NXeuY5UImEy9eo15cb3NXx6GdXW793FaeaSTscSUjGYg4bDQYavGvwaoP6Cd4E0h5aTLSoTQDXY3Q5v7cJkmkIK0imVJrArs7SHKvy3g/VazRdRnVPtoSXz26NqU0Q1SORz4f7pvbMwQHMiIT@ffmgxQanI1yPbheaAN4Ey8XfU41HI5EGeqcUInFX4XqAOmP6QO94tT3vnpFlC7TYdkOs/7ge6m36k5nVMp@d8dyYScTjbcwdLx/l83pzSosl4U1g/mkx3NXfLQbqBlG9q7Po57gS4jma9fsID6l1u3bVqO06hQYOSHC1mUQizt2XvXqwXaFG/gPvYVF9abvFzLUJwE/odCwcYtLddNZPtcgYGpj/yGbTutViTsTqE83lzN9lisp69XLT5azFqpGwAFOVswTHaBMJl5ON9C6zM22iivu9JyuKr3yu1bxeIskP2UAEWLb36giMfzE/2WVJKhV2AYO49jJLQ8JZ117D1lKQk/q@U1vXOriej@ptbVkFR7nBQc9oyW5cePTDtq9q5dcvm8PpcpMer89P/b8@/wM "Malbolge – Try It Online") [Answer] # [Perl 6](https://github.com/nxadm/rakudo-pkg), 12 bytes ``` ~\|('@'x 11) ``` [Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfq65GQ91BvULB0FDzvzVXTmZearGdnZ5aGpAoTqy0/m/ApWtoZGxiamZuYWnAhWACAA "Perl 6 – Try It Online") Anonymous Whatever lambda that takes a number and string ORs it with 11 `@`s. This maps the digits to `pqrstuvwxy` and the dash to `m`, then pads the string out to 11 characters with `@`s [Answer] # [Perl 5](https://www.perl.org/) (-p), 9 bytes ``` $_^=A x$= ``` [Try it online!](https://tio.run/##K0gtyjH9/18lPs7WUaFCxfb/fwMuQy5DI2MTUzNzC0sDLl1DLl0jQxNzEwtjMxMLLjjT/F9@QUlmfl7xf92CHAA "Perl 5 – Try It Online") Bitwxise-xor of the input with the string `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`. [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~44~~ 33 bytes ``` Echo@Table[Or[i>#+13!,],{i,14!}]& ``` [Try it with a smaller domain](https://tio.run/##y00syUjNTSzJTE78n2b73zU5I98hJDEpJzXavyg6005Z2yjORCdWpzpTxyjOtDZW7X@aA1iNspq@Q1BiXnpqtK6hmY6haex/AA) -2 thanks to [Greg Martin](https://codegolf.stackexchange.com/questions/190133/output-with-the-same-length-always/190160?noredirect=1#comment455098_190160) Prints `>>` , followed by the 523069747202-character string representation of a list of \$13!+n\$ `Null`s padded by `True`s to a length of \$14!\$, and a newline. Works on the domain \$[-13!,14!-13!)\$, which is a superset of \$[-2^{31},2^{31})\$. Given the size of the output, I've included a test case with a smaller domain of \$[-2^4,2^4)\$ instead [Answer] # [Stax](https://github.com/tomtheisen/stax), 6 bytes ``` 11){Hm ``` [Run and debug it](https://staxlang.xyz/#c=11%29%7BHm&i=0%0A-1%0A1%0A-2147483648%0A2147483647&a=1&m=2) Procedure:* 1. Left pad input to 11 characters. 2. Double each non-space ascii character. [Answer] # [PHP](https://php.net/), ~~64~~ 54 bytes -10 bytes by using `strtr` function instead of manual character replacement. ``` <?=str_pad(strtr($argn,'-0123456789',ADEFGHIJKLM),20); ``` [Try it online!](https://tio.run/##K8go@P/fxt62uKQoviAxRQNIlxRpqCQWpefpqOsaGBoZm5iamVtYqus4uri6uXt4enn7@GrqGBloWv//r2tpZGRsbG5kYGxmYWpibm5qYWD@L7@gJDM/r/i/rhsA "PHP – Try It Online") Largest int value possible in PHP as of now is `9223372036854775807` which is 19 digits long, considering the minus sign in negative numbers, it will be 20. The code above replaces minus sign (`-`) with the `A` character and every digit from `0` to `9` with a character from `D` to `M` and then pads the string in the right with space character to always make it 20 characters long. For example, the output for input of `-9876543210` is `"AMLKJIHGFED "`. The output is unique for each integer input and you can get back to the input by removing all spaces, replacing `A` with `-` and replacing `D` to `M` with `0` to `9`. --- # [PHP](https://php.net/), 44 bytes ``` <?=str_pad(base64_encode(decbin($argn)),88); ``` [Try it online!](https://tio.run/##BcFLCoAgFADAy7RQSBD/UdGua4g/yo2Kev5eM@1tAMd1jtltcxF5N5ISNpVQY0IxBZ8LWlx/CsarMXgHIBtjnGtGuTJSaC0N1V9tM9cygNw/ "PHP – Try It Online") This is same idea as [Arnauld's answer](https://codegolf.stackexchange.com/a/190138/81663). Converts the input to binary, and then converts it to base-64. Also pads it to 88 characters (largest length is for `-9223372036854775807` which is 88 characters) with space character at right to always get same length in the output. [Answer] # [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 21 bytes ``` T`p`l $ 10$o !`.{11} ``` [Try it online!](https://tio.run/##K0otycxL/P8/JKEgIYdLhcvQQEUrn0sxQa/a0LD2/39dI0MTcxMLYzMTCwA "Retina 0.8.2 – Try It Online") Always outputs 11 characters from the range `n`..`z`. Explanation: ``` T`p`l ``` Translate the printable ASCII characters to the lowercase letters. This maps `-` to `n` and `0`..`9` to `q`..`z`. (It's really fortunate that the digits are the 16th to the 25th printable ASCII characters!) ``` $ 10$o ``` Append 10 `o`s. Since the input will have between 1 and 11 characters, there are now between 11 and 21 characters. ``` !`.{11} ``` Extract the first 11 characters. Since there are fewer than 22 characters, this will only match once. [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes ``` ◧⍘﹪ＮＸχχαχ ``` [Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCMgMcUnNa1EwymxODW4BCiUruGbn1Kak6/hmVdQWuJXmpuUWqShqaMQkF8OZBga6CgYGmgC@YmaEJb1//@6RoYm5iYWxmYmFv91y3IA "Charcoal – Try It Online") Link is to verbose version of code. Always outputs 10 spaces and uppercase letters. Explanation: ``` Ｎ Input as a number ﹪ Modulo χ 10 Ｘ To power χ 10 ⍘ α Convert to base 26 using uppercase letters ◧ χ Left pad to length 10 ``` [Answer] # [R](https://www.r-project.org/), 37 bytes ``` set.seed(scan()) cat(sample(LETTERS)) ``` [Try it online!](https://tio.run/##K/r/vzi1RK84NTVFozg5MU9DU9M6ObFEozgxtyAnVcPHNSTENShYU/O/oZGxiel/AA "R – Try It Online") Looks like the output is random, but it isn't! The input is used as the seed of the Pseudo-Random Number Generator, and we then get one of the \$26!=4\cdot 10^{26}\$ permutations of the alphabet. The output is always of length 51 (26 letters + 25 spaces). There is still the issue of insuring that all the outputs are different. We end up with \$2^{32}\approx 4\cdot 10^9\$ permutations (out of \$4\cdot 10^{26}\$). If we pretend that the permutations are distributed uniformly at random, then the probability that all the permutations are different can be computed following the same calculations as for the [Birthday problem](https://en.wikipedia.org/wiki/Birthday_problem). The probability that 2 specific outputs are identical is \$10^{-17}\$, so a first order approximation of the probability that all \$2^{32}\$ outputs are distinct is \$1-\exp(-2^{64}/26!)\approx0.99999998\$ which is close enough to 1 for me. [Answer] # [brainfuck](https://github.com/TryItOnline/brainfuck), ~~20~~ 19 bytes -1 byte thanks to Krzysztof Szewczyk ``` -[>,[->-<]>.[-]<<-] ``` [Try it online!](https://tio.run/##SypKzMxLK03O/v9fN9pOJ1rXTtcm1k4vWjfWxkY3FihoaGRsYmpmbmFpAAA "brainfuck – Try It Online") Outputs the number with each digit and dash mapped to 255 minus their ordinal value, padded out to 255 characters with NUL bytes. [Answer] # [R](https://www.r-project.org/), ~~40~~ 37 bytes ``` cat(gsub("S","",intToBits(scan())>0)) ``` [Try it online!](https://tio.run/##K/r/PzmxRCO9uDRJQylYSUdJSSczryQk3ymzpFijODkxT0NT085AU/O/wX8A "R – Try It Online") An alternative to [Robin Ryder's answer](https://codegolf.stackexchange.com/a/190188/67312); this is certainly deterministic. This converts the input to a `raw` vector of 32 bytes, each byte being a hex number `00` or `01` representing the bits of the integer. We then coerce to a `logical` by comparing to `0`, so `00` is mapped to `FALSE` and `01` to `TRUE`. Then we need to remove a single letter from each `FALSE` to guarantee equal-length output, arbitrarily selected to be `S`. Result is printed (with space) for a length of 169. [Answer] # [Zsh](https://www.zsh.org/), 43 bytes ``` for c (${(s::)${(l:30::0:)1}})echo \\x$[#c] ``` --- ``` ${(l:30:0:)1} # left-pad with zeroes to 30 characters ${(s::) } # split characterwise for c ( ) # for each character $[#c] # get character code (in decimal) echo \\x$[#c] # interpret as hex code, print (with newline) ``` [Try it online!](https://tio.run/##bYzBCoMwEETv@xULDbUeAslGjd3S/kjtQTRFITSgpZUWv91az5nL8B7DfMZueXe9dzi4ukXfP9wJ2wDuVXsc3ROlRPG3yz0M2OBBfA8jc7qWZ6OYFad6nlPXdAGrahLXXXNbNkrOWxLY6LInFBMyCg1tWP8UaJAaCCSBVmRsBkciYywpU5R5Zm1eqiLiLIKMLSPSxmQJPw "Zsh – Try It Online") This solution gets around the `long long` limits of Zsh's integers by working with only characters. I only padded it to 30 characters for readability, but replacing `30` with `99` will allow this method to work on all numbers from `-1E99+1` to `1E100-1`. The effect of interpreting the decimal codes as hexadecimal are as follows: ``` 0 => 48 => H 1 => 49 => I 2 => 50 => P 3 => 51 => Q 4 => 52 => R 5 => 53 => S 6 => 54 => T 7 => 55 => U 8 => 56 => V 9 => 57 => W - => 45 => E ``` # [Zsh](https://www.zsh.org/), 46 bytes ``` integer -i2 -Z66 x=$1 <<<${${x//[02-]/a}//1/b} ``` [Try it online!](https://tio.run/##jY7NSsQwFEb3eYoPpvgDhrRpp61aXfkUiot0emkDMZEkdarDPHutjIiLLuauLoePw/kKw7wftCF4Uh2MtnSPzjH6UAaBIjhH8kNnbSP15MG1BH8uS0wPScaapkkOyWES4iWV/FWooxCZaI8z7QaHxwuJZMIdlmXnFknKMsYzJhmXLEtlXhXsVso8r2Sal/W2qKptnZYrrMJyGxjlewoRuixuoOxnHLTtT9RDB0Q/2p2K1K0o6pPib4KrQIQnascebozvY0RLxu2vGV9r4utRG4Q3ZcxvFOKglifYy/ivha/HnNXyDQ) Declares x as a binary number, zero-padded to a width of 66. Then maps `0`→`a` and `1`→`b`. We also map `2` and `-` to a, since those characters are printed in `[[-]][base]#[num]` notation. To see what `$x` looks like before replacement, and Zsh's limits in parsing integer types, check the Debug output in the TIO link. [Answer] # [Java (JDK)](http://jdk.java.net/), 42 bytes ``` n->"".format("%8x",n).chars().map(i->i\|64) ``` [Try it online!](https://tio.run/##ZZFvS8MwEMbf71MchUEiaTBuzulcYS8UBs43QxFEJHbtzGzTkqRzQ/fZ6/XP5mAv0rve73IPz2Ul19JfLb5KleaZcbDCf144lfC40KFTmeZno84JtM5EMq1QXnwkKoQwkdbCTCoNPx2AtmqddBjWmVpAiozMnVF6@foG0iwtrVsB7lul26l20TIyDOO8FggghnGp/cDzeJyZVDridYcbj2nKw09pLKE8lTlRfqB@B31ajuqBSjuUcJF1FsatCMA5A8HggkGPQZ/BJYMBgysGQwbXiCqMXGCDwA6BLQJ7xIDt728qXn334RD/k6PsOBXtDB@LPir4vf3U1jOfTV7enycPT3cnYPrYgLq@axziMgi6rD3eNE7pweh8a12U8qxwPMd1uxiXJoQFP4Cu7WqP1RcY6OgbmgchMZd5nmxJBSh32cQYuSWUVUsbUtqI7jrV2ZV/ "Java (JDK) – Try It Online") First, this creates the hexadecimal representation of the input, left-padded with spaces which provides the same length constraint (8 characters-long), removes the minus sign, and keeps each intermediate output unique. This gives a string with 17 different possible characters: `0123456789abcdef` and space. Then each character is streamed and mapped by adding 64 to its codepoint if it's a digit or a space. Effectively, this results in the following mapping: `0123456789abcdef<space>` to `pqrstuvwxyabcdef`` which has 17 different characters, so no two numbers will result in the same output. [Answer] # [Bash](https://www.gnu.org/software/bash/), 30 bytes ``` echo $1\|md5sum\|tr '0-9-' 'A-K' ``` [Try it online!](https://tio.run/##S0oszvj/PzU5I19BxbAmN8W0uDS3pqRIQd1A11JXXUHdUddb/f///7qGRsZGhkYA "Bash – Try It Online") To prove that output is unique, I just googled for MD5 collisions, and found no results within the integers between \$-2^{31}\$ and \$2^{31}\$. To avoid having forbidden characters in the output, just translate the characters in question to be upper case letters. Output is always the same length by definition, and guaranteed to not contain any forbidden characters. ]
[Question] [ This idea is loosely based upon @TùxCräftîñg's [chat message.](http://chat.stackexchange.com/transcript/message/32094684#32094684) Take a look at the below example sequence: `INVALID0`, `INVALID1`, `INVALID2` `INVALID3`, `INVALID4`... `INVALID9` After `INVALID9`, it goes on like this: `INVALI0`, `INVALI1`, `INVALI2`, `INVALI3`... `INVALI9` And after `INVALI9`, it's like this: `INVAL0`,`INVAL1`, `INVAL2`, `INVAL3`... `INVAL9` After, `INVAL9`, it's like this: `INVA0`, `INVA1`, `INVA2`, `INVA3`, ... `INVA9` Notice how we we kept removing a letter from the word `INVALID` each time. You'll keep repeating this until you reach a single letter, that is, the letter `I`: `I0`, `I1`, `I2`, `I3`, `I4` ... `I9` Now, your task is, to take an input of a word, and produce a sequence from it like the above example. Your code must also work with single letters, and in that case the resulting sequence will be shorter. You may choose any input and output format that you prefer (with or without a separator, as you wish), but you must specify which one you have chosen. The sequence needs to be in the exact specified order. The shortest code, in bytes, that successfully completes this challenge, wins the challenge. Full sequence in the above example: ``` INVALID0, INVALID1, INVALID2, INVALID3, INVALID4, INVALID5, INVALID6, INVALID7, INVALID8, INVALID9, INVALI0, INVALI1, INVALI2, INVALI3, INVALI4, INVALI5, INVALI6, INVALI7, INVALI8, INVALI9, INVAL0, INVAL1, INVAL2, INVAL3, INVAL4, INVAL5, INVAL6, INVAL7, INVAL8, INVAL9, INVA0, INVA1, INVA2, INVA3, INVA4, INVA5, INVA6, INVA7, INVA8, INVA9, INV0, INV1, INV2, INV3, INV4, INV5, INV6, INV7, INV8, INV9, IN0, IN1, IN2, IN3, IN4, IN5, IN6, IN7, IN8, IN9, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 ``` Other examples: Input: `MAYBE` (Uppercase and lowercase don't matter) Output: ``` MAYBE0, MAYBE1, MAYBE2, MAYBE3, MAYBE4, MAYBE5, MAYBE6, MAYBE7, MAYBE8, MAYBE9, MAYB0, MAYB1, MAYB2, MAYB3, MAYB4, MAYB5, MAYB6, MAYB7, MAYB8, MAYB9, MAY0, MAY1, MAY2, MAY3, MAY4, MAY5, MAY6, MAY7, MAY8, MAY9, MA0, MA1, MA2, MA3, MA4, MA5, MA6, MA7, MA8, MA9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9 ``` --- --- Input: `AFTER` Output: ``` AFTER0, AFTER1, AFTER2, AFTER3, AFTER4, AFTER5, AFTER6, AFTER7, AFTER8, AFTER9, AFTE0, AFTE1, AFTE2, AFTE3, AFTE4, AFTE5, AFTE6, AFTE7, AFTE8, AFTE9, AFT0, AFT1, AFT2, AFT3, AFT4, AFT5, AFT6, AFT7, AFT8, AFT9, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, AF8, AF9, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9 ``` --- --- Input: `WHAT ARE YOU DOING` ``` WHAT ARE YOU DOING0, WHAT ARE YOU DOING1, WHAT ARE YOU DOING2, WHAT ARE YOU DOING3, WHAT ARE YOU DOING4, WHAT ARE YOU DOING5, WHAT ARE YOU DOING6, WHAT ARE YOU DOING7, WHAT ARE YOU DOING8, WHAT ARE YOU DOING9, WHAT ARE YOU DOIN0, WHAT ARE YOU DOIN1, WHAT ARE YOU DOIN2, WHAT ARE YOU DOIN3, WHAT ARE YOU DOIN4, WHAT ARE YOU DOIN5, WHAT ARE YOU DOIN6, WHAT ARE YOU DOIN7, WHAT ARE YOU DOIN8, WHAT ARE YOU DOIN9, WHAT ARE YOU DOI0, WHAT ARE YOU DOI1, WHAT ARE YOU DOI2, WHAT ARE YOU DOI3, WHAT ARE YOU DOI4, WHAT ARE YOU DOI5, WHAT ARE YOU DOI6, WHAT ARE YOU DOI7, WHAT ARE YOU DOI8, WHAT ARE YOU DOI9, WHAT ARE YOU DO0, WHAT ARE YOU DO1, WHAT ARE YOU DO2, WHAT ARE YOU DO3, WHAT ARE YOU DO4, WHAT ARE YOU DO5, WHAT ARE YOU DO6, WHAT ARE YOU DO7, WHAT ARE YOU DO8, WHAT ARE YOU DO9, WHAT ARE YOU D0, WHAT ARE YOU D1, WHAT ARE YOU D2, WHAT ARE YOU D3, WHAT ARE YOU D4, WHAT ARE YOU D5, WHAT ARE YOU D6, WHAT ARE YOU D7, WHAT ARE YOU D8, WHAT ARE YOU D9, WHAT ARE YOU 0, WHAT ARE YOU 1, WHAT ARE YOU 2, WHAT ARE YOU 3, WHAT ARE YOU 4, WHAT ARE YOU 5, WHAT ARE YOU 6, WHAT ARE YOU 7, WHAT ARE YOU 8, WHAT ARE YOU 9, WHAT ARE YOU0, WHAT ARE YOU1, WHAT ARE YOU2, WHAT ARE YOU3, WHAT ARE YOU4, WHAT ARE YOU5, WHAT ARE YOU6, WHAT ARE YOU7, WHAT ARE YOU8, WHAT ARE YOU9, WHAT ARE YO0, WHAT ARE YO1, WHAT ARE YO2, WHAT ARE YO3, WHAT ARE YO4, WHAT ARE YO5, WHAT ARE YO6, WHAT ARE YO7, WHAT ARE YO8, WHAT ARE YO9, WHAT ARE Y0, WHAT ARE Y1, WHAT ARE Y2, WHAT ARE Y3, WHAT ARE Y4, WHAT ARE Y5, WHAT ARE Y6, WHAT ARE Y7, WHAT ARE Y8, WHAT ARE Y9, WHAT ARE 0, WHAT ARE 1, WHAT ARE 2, WHAT ARE 3, WHAT ARE 4, WHAT ARE 5, WHAT ARE 6, WHAT ARE 7, WHAT ARE 8, WHAT ARE 9, WHAT ARE0, WHAT ARE1, WHAT ARE2, WHAT ARE3, WHAT ARE4, WHAT ARE5, WHAT ARE6, WHAT ARE7, WHAT ARE8, WHAT ARE9, WHAT AR0, WHAT AR1, WHAT AR2, WHAT AR3, WHAT AR4, WHAT AR5, WHAT AR6, WHAT AR7, WHAT AR8, WHAT AR9, WHAT A0, WHAT A1, WHAT A2, WHAT A3, WHAT A4, WHAT A5, WHAT A6, WHAT A7, WHAT A8, WHAT A9, WHAT 0, WHAT 1, WHAT 2, WHAT 3, WHAT 4, WHAT 5, WHAT 6, WHAT 7, WHAT 8, WHAT 9, WHAT0, WHAT1, WHAT2, WHAT3, WHAT4, WHAT5, WHAT6, WHAT7, WHAT8, WHAT9, WHA0, WHA1, WHA2, WHA3, WHA4, WHA5, WHA6, WHA7, WHA8, WHA9, WH0, WH1, WH2, WH3, WH4, WH5, WH6, WH7, WH8, WH9, W0, W1, W2, W3, W4, W5, W6, W7, W8, W9 ``` ### Leaderboard ``` var QUESTION_ID=92156,OVERRIDE_USER=58717;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+)(?=[^\n\d<>](?:<(?:s>[^\n<>]<\/s>\|[^\n<>]+>)[^\n\d<>])<\/h\d>)/,OVERRIDE_REG=/^Override\sheader:\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> ``` [Answer] ## Javascript (ES6), ~~53~~ 47 bytes ``` f=(s,n=0)=>s&&s+n+f(n-9?s:s.slice(0,-1),++n%10) ``` Saved 6 bytes thanks to Peanut & Neil* Output: all words as a single string with no separator. ### Example ``` var f=(s,n=0)=>s&&s+n+f(n-9?s:s.slice(0,-1),++n%10) document.getElementsByTagName('div')[0].innerHTML = f('INVALID') ``` ``` <div style="word-wrap:break-word"></div> ``` [Answer] # [05AB1E](http://github.com/Adriandmen/05AB1E), ~~10~~ 8 bytes ``` .pžmâ€JR ``` Explanation ``` .p # get prefixes of input žmâ # cartesian product with [9..0] €J # join each R # reverse ``` [Try it online!](http://05ab1e.tryitonline.net/#code=LnDFvm3DouKCrEpS&input=V0hBVCBBUkUgWU9VIERPSU5H) Saved 2 bytes thanks to [Adnan](https://codegolf.stackexchange.com/users/34388/adnan) [Answer] # Perl, 29 bytes Includes +1 for `-n` Run with input on STDIN: ``` perl -nE '/^.+(?{map{say$&.$_}0..9})^/' <<< PERL ``` Just the code: ``` /^.+(?{map{say$&.$_}0..9})^/ ``` [Answer] ## Haskell, ~~47~~ 43 bytes ``` f""=[] f x=map((x++).show)[0..9]++f(init x) ``` Usage example: `f "IN"` -> `["IN0","IN1","IN2","IN3","IN4","IN5","IN6","IN7","IN8","IN9","I0","I1","I2","I3","I4","I5","I6","I7","I8","I9"]`. Simple recursive approach. Append each digit to the word and append a recursive call with last letter removed. [Answer] # Pyth, 9 bytes ``` sM_._QUT ``` A program that takes input of a quoted string on STDIN and prints a list of strings. [Try it online](https://pyth.herokuapp.com/?code=sM%2a_._QUT&test_suite=1&test_suite_input=%22INVALID%22%0A%22MAYBE%22%0A%22AFTER%22%0A%22WHAT+ARE+YOU+DOING%22&debug=0) How it works* ``` sM_._QUT Program. Input: Q ._ List of prefixes of Q _ Reverse UT Unary range up to 10, yielding [0, 1, 2, ..., 9] Cartesian product of the above two sM Map concatenate over the above Implicitly print ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` ḣJṚp⁵Ḷ¤ ``` [Try it online!](http://jelly.tryitonline.net/#code=4bijSuG5mnDigbXhuLbCpA&input=&args=TUFZQkU) ### How it works ``` ḣJṚp⁵Ḷ¤ Main link. Argument: s (string) J Yield all (1-based) indices of s. ḣ Head; for each index k, take the first k characters of s. Ṛ Reverse the result. ¤ Combine the two links to the left into a niladic chain. ⁵ Yield 10. Ḷ Unlength; yield [0, ..., 9]. p Return the Cartesian product of the prefixes and the range. (implicit) Print the Cartesian product without separators. ``` [Answer] ## [Pip](http://github.com/dloscutoff/pip), ~~12~~ 11 bytes Takes the word as a cmdline argument. Outputs with no separators. ``` Wa&Oa.,tDQa ``` [Try it online!](http://pip.tryitonline.net/#code=V2EmT2EuLHREUWE&input=&args=SUY) Explanation: ``` Implicit: a = 1st cmdline arg, t = 10 Wa While a (i.e. while it's not the empty string) Oa.,t Concatenate range(10) to a and output (Pip concatenates a string to a range itemwise) & The output operation is &-ed to the loop condition to save on curly braces DQa Dequeue from a, removing the final character on each iteration ``` [Answer] # [V](http://github.com/DJMcMayhem/V), 20 bytes ``` A0òYpó.10/0/e $hòd ``` [Try it online!](http://v.tryitonline.net/#code=QTAbw7JZcAHDsy4xMC8wL2UKJGjDsmQ&input=SU5WQUxJRA) Since this contains unprintable characters, here is the readable format: ``` A0<esc>òYp<C-a>ó.10/0/e $hòd ``` And here is a hexdump: ``` 0000000: 4130 1bf2 5970 01f3 2e31 302f 302f 650a A0..Yp...10/0/e. 0000010: 2468 f264 $h.d ``` Explanation: ``` A0<esc> "Append a '0' to the input ò "Recursively: Yp " Yank this line and paste it <C-a> " Increment the first number on this line ó " Substitute: .10 " Any single character followed by '10' /0 " Replace it with a '0' /e " Ignore errors if this is not found $h " Move to the end of the end of this line than back one. " This makes it so the loop ends once there is only one " character on this line. ò "End the loop d "Delete a line (since we create one too many) ``` [Answer] # Bash + coreutils, 54 bytes: ``` for i in `seq ${#1} 1`;{ printf "${1:0:i}%s " {0..9};} ``` Simply loops through a sequence `[Length of Input,1]` and during each iteration, outputs the input word to the length of current iteration value `9` times with each number in `[0,9]` appended to each of the `9` copies of the word. Execute it within a file and the word or words in quotes, i.e. `bash A.sh "blah blah blah"`. [Answer] # [Floroid](https://github.com/TuukkaX/Floroid) - 50 47 31 bytes ``` f=Ba:aM[a+b KbIhd]+f(a[:-1])H[] ``` Currently uses a similar method as [@JonathanAllan](https://codegolf.stackexchange.com/users/53748/jonathan-allan) uses on his second recursive method. Could've been this if I would've implemented the cartesian product more carefully in the language: `Bc:ca([c]+[c[:-a-1]KaIw(Z(c)-1)],hd)`. ## Testcases ``` Input: ABC Output: ['ABC0', 'ABC1', 'ABC2', 'ABC3', 'ABC4', 'ABC5', 'ABC6', 'ABC7', 'ABC8', 'ABC9', 'AB0', 'AB1', 'AB2', 'AB3', 'AB4', 'AB5', 'AB6', 'AB7', 'AB8', 'AB9', 'A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9'] Input: M Output: ['M0', 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'M8', 'M9'] ``` [Answer] # (lambdabot) Haskell - 49 bytes ``` f q=[x++show n\|x<-reverse.tail$inits q,n<-[0..9]] ``` Lambdabot is a IRC bot over at #haskell; it automatically imports a bunch of modules, including `Data.List` which is where `inits` live. And because a language is defined by its implementation, I can call this lambdabot haskell and not pay the bytes for the imports. Regular Haskell: ``` import Data.List f q=[x++show n\|x<-reverse.tail$inits q,n<-[0..9]] ``` [Answer] # [braingasm](https://github.com/daniero/braingasm/tree/develop), ~~34~~ ~~33~~ ~~31~~ 28 bytes At its current state, braingasm is just glorified brainfuck with a few (like, 3?) extra features. I've been spending most of the development time making it as "enterprisy" as possible, instead of actually adding features... Anyways, the following code should work with the latest development snapshot. It takes newline-less input from stdin, like `$ echo -n INVALID \| braingasm invalid.bg`, and prints to stdout. ``` ,[>,]#[48+10[#<[.>]<+]0,<0,] ``` Explanation: ``` ,[>,] lay down the input on the tape #[ (length of input - 1) times do 48+ add '0' at the end of the tape 10[ 10 times do #<[.>] move to start of tape, then print the tape <+ increase the number at the end of the tape ] done printing current word with 0 through 9 0, erase the number by writing 0 onto it <0, likewise, remove one character ] done ``` edit: Appearantly it's OK to ~~skip~~ use empty string as the delimiter [Answer] # Python 2, ~~53~~ 55 bytes +2 bytes: declaring f is necessary with recursion (as pointed out by @Destructible Watermelon) ``` f=lambda s:s and[s+`n`for n in range(10)]+f(s[:-1])or[] ``` Recurses down to the empty string (yielding an empty list), chops off a character at a time, and prepends with a list of ten of the current string with the digits 0-9 appended to each. Test on [ideone](http://ideone.com/pYh024) Python 3, ~~54~~ 56 bytes ``` f=lambda s:s and[s+n for n in'0123456789']+f(s[:-1])or[] ``` Test on [ideone](http://ideone.com/rs51DI) [Answer] # Swift 3, 150 Bytes Not quite the shortest solution, but not terrible for Swift ``` func a(s: String){var c=s.characters,r="";while(c.count>0){var k = "";for d in c{k+=String(d)};for i in 0...9{r+="\(k)\(i) "};c.removeLast()};print(r);} ``` [Test this online in the IBM Swift Sandbox](http://swiftlang.ng.bluemix.net/#/repl/57cbb1f60c6d102e1d393a89) ### Ungolfed ``` func a(s s: String){ var c = s.characters, r = "" while(c.count > 0){ var k = "" for d in c{ k+=String(d) } for i in 0...9{ r+="\(k)\(i) " } c.removeLast() } print(r) } ``` [Answer] # Ruby, 51 No separator used. ``` ->s{(10n=s.size).times{\|i\|print s[0,n-i/10],i%10}} ``` Add the following after `i%10` for separators: `,$/` for newline, `,?\|` for `\|` (similar for any printable character), `,' '` for space. In test program* ``` f=->s{(10n=s.size).times{\|i\|print s[0,n-i/10],i%10}} f[gets.chomp] ``` [Answer] # PHP, ~~64~~ 56 bytes ``` for($i=9;$a=substr($argv[1].a,0,-++$i/10);)echo$a.$i%10; ``` ``` for(;$a=substr($argv[1].a,$i=0,-++$l);)for(;$i<10;)echo $a.$i++; ``` [Answer] ## Haskell, ~~49~~ 46 bytes ``` f=(>>=(<$>['0'..'9']).snoc).reverse.tail.inits ``` [Answer] # C#, ~~107~~ 102 Bytes ``` string f(string i){var o="";while(i!=""){for(int k=0;k<=9;)o+=i+k++;i=i.Remove(i.Length-1);}return o;} ``` Ungolfed* ``` string f(string i) { string o = ""; while(i != "") { for (int k = 0; k <= 9;) o += i + k++; i = i.Remove(i.Length - 1); } return o; } ``` [Answer] ## Ruby, ~~90~~ 85 bytes ``` f=->s{if s=="";return[];end;(0..9).map{\|i\|s+i.to_s}+f[s.chars.take(s.length-1).join]} ``` If the string is empty, return a empty array. Otherwise, generate the string + the number in each number from 0 to 9, and call `f` with the string without the last character. Saved 5 bytes thanks to @LevelRiverSt [Answer] ## Perl 6, 32 = 31 bytes + 1 for -p I'm not all that proficient with Perl 6, so there may be ways to reduce it even more. ``` $_= ~((~$_,.chop...^!)X~ ^10) ``` It uses `-p` to evaluate once for each input line. The line is placed into `$_` and after the program runs, it prints `$_`. The `(~$_,.chop...^!)` is a list where the first element is stringified (`~`) input, each subsequent element is obtained by chopping the last character off the previous one (`.chop`) and that continues until the string is empty (`!`), excluding the empty string case (the `^` in `...^`). `X~` generates all pairs of the lists on the left and right, using the specified operation, in this case, the string concatenation (`~`) on them. `^10` is a list of 0, 1, ... 9. Finally, the list is stringified again with `~`, giving the required words with space as a separator. [Answer] ## PowerShell v2+, 60 bytes ``` param($n)$n.length..1\|%{$i=$_-1;0..9\|%{-join$n[0..$i]+"$_"}} ``` Loops from the length of the input string down to `1`. Each iteration, set helper `$i` equal to the current number minus `1`. This is necessary because `.length` is the total number of characters, but indexing a string is 0-based. Then, we loop from `0` to `9`. Each inner loop, slice the input string `$n` based on the value of our outer loop, `-join` it back into a string, and string-concatenate on the inner loop count. Each individual loop result is placed on the pipeline, and output is implicit at program completion. ``` PS C:\Tools\Scripts\golfing> .\invalid-invali-inval.ps1 'foo' foo0 foo1 foo2 foo3 foo4 foo5 foo6 foo7 foo8 foo9 fo0 fo1 fo2 fo3 fo4 fo5 fo6 fo7 fo8 fo9 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 ``` [Answer] # [Dyalog APL](http://goo.gl/9KrKoM), ~~14~~ 11 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319) Returns list of strings. ``` ,⎕D∘.,⍨⌽,\⍞ ``` `,` listify (make table into list) `⎕D` all digits `∘.,⍨` appended to all of (i.e. making all combinations with) `⌽` the reversed list of `,\` the cumulative concatenation of `⍞` the text input [TryAPL online!](http://tryapl.org/?a=%u2359%u2190%27APL%27%20%u22C4%20%2C%u2395D%u2218.%2C%u2368%u233D%2C%5C%u2359&run) [Answer] # Groovy (58 Bytes) No idea why I'm even bothering to post a Groovy answer... The minimum required size for a Groovy golf is 2 based on needing a closure, so the best answer here is double my minimum size. ``` {s->(s.length()-1..0).each{c->10.times{print s[0..c]+it}}} ``` Try it here: <https://groovyconsole.appspot.com/script/5148433803378688> [Answer] ## Batch, ~~85~~ 83 bytes ``` @for /l %%i in (0,1,9)do @echo %1%%i @set s=%1 @if not "%s:~,-1%"=="" %0 %s:~,-1% ``` [Answer] # Java 7, ~~105~~ 98 bytes ``` void c(String s){for(int x=0,l=s.length();x<l10;)System.out.print(s.substring(0,l-x/10)+x++%10);} ``` -7 bytes thanks to @Poke. Ungolfed: ``` void c(String s){ for(int x = 0, l = s.length(); x < l10; ){ System.out.print(s.substring(0, l - x/10) + x++ % 10); } } ``` Test code: [Try it here.](https://ideone.com/6qeBNv) ``` class M{ static void c(String s){for(int x=0,l=s.length();x<l10;)System.out.print(s.substring(0,l-x/10)+x++%10);} public static void main(String[] a){ c("INVALID"); System.out.println(); c("MAYBE"); System.out.println(); c("AFTER"); System.out.println(); c("WHAT ARE YOU DOING"); } } ``` Output:* ``` INVALID0INVALID1INVALID2INVALID3INVALID4INVALID5INVALID6INVALID7INVALID8INVALID9INVALID0INVALID1INVALID2INVALID3INVALID4INVALID5INVALID6INVALID7INVALID8INVALID9INVALI0INVALI1INVALI2INVALI3INVALI4INVALI5INVALI6INVALI7INVALI8INVALI9INVAL0INVAL1INVAL2INVAL3INVAL4INVAL5INVAL6INVAL7INVAL8INVAL9INVA0INVA1INVA2INVA3INVA4INVA5INVA6INVA7INVA8INVA9INV0INV1INV2INV3INV4INV5INV6INV7INV8INV9IN0IN1IN2IN3IN4IN5IN6IN7IN8IN9I0I1I2I3I4I5I6I7I8I9 MAYBE0MAYBE1MAYBE2MAYBE3MAYBE4MAYBE5MAYBE6MAYBE7MAYBE8MAYBE9MAYBE0MAYBE1MAYBE2MAYBE3MAYBE4MAYBE5MAYBE6MAYBE7MAYBE8MAYBE9MAYB0MAYB1MAYB2MAYB3MAYB4MAYB5MAYB6MAYB7MAYB8MAYB9MAY0MAY1MAY2MAY3MAY4MAY5MAY6MAY7MAY8MAY9MA0MA1MA2MA3MA4MA5MA6MA7MA8MA9M0M1M2M3M4M5M6M7M8M9 AFTER0AFTER1AFTER2AFTER3AFTER4AFTER5AFTER6AFTER7AFTER8AFTER9AFTER0AFTER1AFTER2AFTER3AFTER4AFTER5AFTER6AFTER7AFTER8AFTER9AFTE0AFTE1AFTE2AFTE3AFTE4AFTE5AFTE6AFTE7AFTE8AFTE9AFT0AFT1AFT2AFT3AFT4AFT5AFT6AFT7AFT8AFT9AF0AF1AF2AF3AF4AF5AF6AF7AF8AF9A0A1A2A3A4A5A6A7A8A9 WHAT ARE YOU DOING0WHAT ARE YOU DOING1WHAT ARE YOU DOING2WHAT ARE YOU DOING3WHAT ARE YOU DOING4WHAT ARE YOU DOING5WHAT ARE YOU DOING6WHAT ARE YOU DOING7WHAT ARE YOU DOING8WHAT ARE YOU DOING9WHAT ARE YOU DOING0WHAT ARE YOU DOING1WHAT ARE YOU DOING2WHAT ARE YOU DOING3WHAT ARE YOU DOING4WHAT ARE YOU DOING5WHAT ARE YOU DOING6WHAT ARE YOU DOING7WHAT ARE YOU DOING8WHAT ARE YOU DOING9WHAT ARE YOU DOIN0WHAT ARE YOU DOIN1WHAT ARE YOU DOIN2WHAT ARE YOU DOIN3WHAT ARE YOU DOIN4WHAT ARE YOU DOIN5WHAT ARE YOU DOIN6WHAT ARE YOU DOIN7WHAT ARE YOU DOIN8WHAT ARE YOU DOIN9WHAT ARE YOU DOI0WHAT ARE YOU DOI1WHAT ARE YOU DOI2WHAT ARE YOU DOI3WHAT ARE YOU DOI4WHAT ARE YOU DOI5WHAT ARE YOU DOI6WHAT ARE YOU DOI7WHAT ARE YOU DOI8WHAT ARE YOU DOI9WHAT ARE YOU DO0WHAT ARE YOU DO1WHAT ARE YOU DO2WHAT ARE YOU DO3WHAT ARE YOU DO4WHAT ARE YOU DO5WHAT ARE YOU DO6WHAT ARE YOU DO7WHAT ARE YOU DO8WHAT ARE YOU DO9WHAT ARE YOU D0WHAT ARE YOU D1WHAT ARE YOU D2WHAT ARE YOU D3WHAT ARE YOU D4WHAT ARE YOU D5WHAT ARE YOU D6WHAT ARE YOU D7WHAT ARE YOU D8WHAT ARE YOU D9WHAT ARE YOU 0WHAT ARE YOU 1WHAT ARE YOU 2WHAT ARE YOU 3WHAT ARE YOU 4WHAT ARE YOU 5WHAT ARE YOU 6WHAT ARE YOU 7WHAT ARE YOU 8WHAT ARE YOU 9WHAT ARE YOU0WHAT ARE YOU1WHAT ARE YOU2WHAT ARE YOU3WHAT ARE YOU4WHAT ARE YOU5WHAT ARE YOU6WHAT ARE YOU7WHAT ARE YOU8WHAT ARE YOU9WHAT ARE YO0WHAT ARE YO1WHAT ARE YO2WHAT ARE YO3WHAT ARE YO4WHAT ARE YO5WHAT ARE YO6WHAT ARE YO7WHAT ARE YO8WHAT ARE YO9WHAT ARE Y0WHAT ARE Y1WHAT ARE Y2WHAT ARE Y3WHAT ARE Y4WHAT ARE Y5WHAT ARE Y6WHAT ARE Y7WHAT ARE Y8WHAT ARE Y9WHAT ARE 0WHAT ARE 1WHAT ARE 2WHAT ARE 3WHAT ARE 4WHAT ARE 5WHAT ARE 6WHAT ARE 7WHAT ARE 8WHAT ARE 9WHAT ARE0WHAT ARE1WHAT ARE2WHAT ARE3WHAT ARE4WHAT ARE5WHAT ARE6WHAT ARE7WHAT ARE8WHAT ARE9WHAT AR0WHAT AR1WHAT AR2WHAT AR3WHAT AR4WHAT AR5WHAT AR6WHAT AR7WHAT AR8WHAT AR9WHAT A0WHAT A1WHAT A2WHAT A3WHAT A4WHAT A5WHAT A6WHAT A7WHAT A8WHAT A9WHAT 0WHAT 1WHAT 2WHAT 3WHAT 4WHAT 5WHAT 6WHAT 7WHAT 8WHAT 9WHAT0WHAT1WHAT2WHAT3WHAT4WHAT5WHAT6WHAT7WHAT8WHAT9WHA0WHA1WHA2WHA3WHA4WHA5WHA6WHA7WHA8WHA9WH0WH1WH2WH3WH4WH5WH6WH7WH8WH9W0W1W2W3W4W5W6W7W8W9 ``` [Answer] # Python 3, 62 bytes ``` lambda x:[(x+" ")[:~i//10]+str(i%10)for i in range(len(x)10)] ``` Doesn't use recursion like the other answer. The reason the " " in `x+" "` is there: -0 is still zero, and so we can't use minus notation to get all of the string in this way so the highest we can go is minus one, so the " " is to pad the string, [Answer] # C, ~~72~~, 70 bytes ``` j;F(chars,int l){while(l--)for(j=0;j<10;)printf("%.s%d",l+1,s,j++);} ``` Takes strings as pointer/size pairs. Test main: ``` int main() { F("INVALID", 7); putchar('\n'); F("MAYBE", 5); putchar('\n'); F("AFTER", 5); putchar('\n'); F("WHAT ARE YOU DOING", 18); putchar('\n'); } ``` [Answer] # [Retina](http://github.com/mbuettner/retina), 37 bytes Byte count assumes ISO 8859-1 encoding. ``` M&!r`.+ m`$ 0 %{`$ ¶$%` T`w`d`.$ G10` ``` [Try it online!](http://retina.tryitonline.net/#code=TSYhcmAuKwptYCQKMAole2AkCsK2JCVgClRgd2BkYC4kCkcxMGA&input=SU5WQUxJRA) ### Explanation ``` M&!r`.+ ``` Get all prefixes of the input by matching and printing all overlapping matches from the right. ``` m`$ 0 ``` Append a `0` to each line. ``` %{`$ ¶$%` ``` The `{` indicates that the remaining three stages are executed in a loop until they fail to change the string. The `%` says that they should be applied to each line separately. The stage itself simply duplicates the last line (initially this is just the line this is run on, but each iteration of the three stages adds another line). ``` T`w`d`.$ ``` Increment the digit in the last row by performing the following character substitution: ``` from: _0123456789AB... to: 0123456789 ``` And finally: ``` G10` ``` Keep only the first 10 lines, so that we remove the line we just added after `INPUT9`. [Answer] # Scala, 73 70 bytes ``` def g(s:String):String=if(s=="")""else(0 to 9 flatMap(s+_))++g(s.init) ``` Call it like `f("INVALID")`. Returns a Sequence of Chars. ### Explanation ``` def g(s:String):String= //defines a method g taking a String as a parameter //and returning a String if(s=="")"" //guard to prevent infinite recursion else (0 to 9 //create a Range from 0 to 9 (inclusive) flatMap( //map: s+_ //append each number to the string )) //and flatten ++ g(s.init) //concatenate with g applied to everything but the last element of s ``` ## Alternative solution, 73 bytes ``` (s:String)=>s.scanLeft("")(_+_).tail.reverse.flatMap(x=>(0 to 9)map(x+_)) ``` defines an anonymous function. To call it, write ``` val f = ... ``` and call it like this ``` f("INVALID") ``` It returns a sequence of strings, which will look like this when printed: ``` Vector(INVALID0, INVALID1, INVALID2, INVALID3, INVALID4, INVALID5, INVALID6, INVALID7, INVALID8, INVALID9, INVALI0, INVALI1, INVALI2, INVALI3, INVALI4, INVALI5, INVALI6, INVALI7, INVALI8, INVALI9, INVAL0, INVAL1, INVAL2, INVAL3, INVAL4, INVAL5, INVAL6, INVAL7, INVAL8, INVAL9, INVA0, INVA1, INVA2, INVA3, INVA4, INVA5, INVA6, INVA7, INVA8, INVA9, INV0, INV1, INV2, INV3, INV4, INV5, INV6, INV7, INV8, INV9, IN0, IN1, IN2, IN3, IN4, IN5, IN6, IN7, IN8, IN9, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) ``` ### Explanation ``` s.scanLeft("")(_+_) //accumulate letters from left to right -> Vector("", "I", "IN", "INV", "INVA", "INVAL", "INVALI", "INVALID") .tail //drop the first element .reverse //reverse it .flatMap(x => //map each element called x (0 to 9) //create a Range from 0 to 9 (inclusive) map(x+_) //append each number to x ) //and flatten ``` [Answer] # CJam, ~~29~~ 28 bytes ``` ls_,,:)W%]~{_[X<aAA,]zo}fX; ``` Explanation: ``` ls read input as string _ duplicate input ,, create range of length input :)W%] add 1 to all elements and reverse ~ dump array on stack { }fX for loop _ duplicate input string [X<aA* slice input string and multiply by 10 A,] range(10) zo zip array and print (no separator) ; clear stack ``` [Try it online](http://cjam.tryitonline.net/#code=bHNfLCw6KVclXX57X1tYPGFBKkEsXXpvfWZYOw&input=V0hBVCBBUkUgWU9VIERPSU5HPw) ]
[Question] [ # Objective Your goal is to make a program that converts an input to its acronym. Your input is guaranteed to have only letters and spaces. The input will have exactly one space between words. You must output the acronym of the input. # Rules * Your code cannot be case-sensitive(e.g. `foo` and `Foo` are the same) * Your code must ignore the following words and not put them in the acronym: `and or by of` * You cannot assume that the words are all lowercase. * The output must be entirely capitalised, with no separation between characters. * A trailing newline is accepted but not necessary. * If your language has an acronym function builtin, you may not use it. ## Examples (inputs/outputs grouped) ``` United States of America USA Light Amplification by Stimulation of Emitted Radiation LASER united states of america USA Jordan Of the World JTW ``` # Scoring This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge so the shortest code wins. # Leaderboard ``` var QUESTION_ID=75448,OVERRIDE_USER=8478;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+)(?=[^\n\d<>](?:<(?:s>[^\n<>]<\/s>\|[^\n<>]+>)[^\n\d<>])<\/h\d>)/,OVERRIDE_REG=/^Override\sheader:\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> ``` [Answer] # Pyth, ~~25~~ ~~21~~ 20 bytes ``` shM-crz1dc4."@YK½¼ ``` [Try it here!](http://pyth.herokuapp.com/?code=shM-crz1dc4.%22%40YK%19%17%C2%BD%C2%BC&input=United+States+of+America&test_suite=1&test_suite_input=United+States+of+America%0ALight+Amplification+by+Stimulation+of+Emitted+Radiation%0Aunited+states+of+america&debug=0) Thanks to @Jakube for saving one byte! ## Explanation ``` shM-crz1dc4."@YK½¼ # z = input rz1 # convert input to uppercase c d # split input on spaces c4."@YK½¼ # create a list of the words from a packed string which shall be ignored - # filter those words out hM # only take the first letter of all words s # join them into one string ``` The packed string becomes `ANDBYOROF` [Answer] ## [Jelly](https://github.com/DennisMitchell/jelly), ~~21~~ [20 bytes](https://github.com/DennisMitchell/jelly/blob/master/docs/code-page.md) ``` ,“°ɲịĊs°gɗ»ṣ€⁶Œuḟ/Ḣ€ ``` [Try it online!](http://jelly.tryitonline.net/#code=LOKAnMKwybLhu4vEinPCsGfJl8K74bmj4oKs4oG2xZJ14bifL-G4ouKCrA&input=&args=byBieXBhc3MgYSBsYXlieSBhbmQgdGFrZSBhbiBhbnRpIGJ5IGNha2U) (-1 thanks to @Dennis.)* ``` ,“°ɲịĊs°gɗ» Pair input with the string "OR OF by AND" ṣ€⁶ Split both by spaces Œu Uppercase ḟ/ Reduce filter (removing ignored words from input) Ḣ€ Keep first letters of remaining words ``` Jelly's dictionary is a bit weird in that it has `AND` in uppercase yet `by` in lowercase... [Answer] ## Retina, 29 ~~31~~ ~~36~~ bytes ``` T`l`L \|(AND\|OR\|BY\|OF)\b\|\B. ``` Intended newline at the end. Thanks to [Martin Büttner](https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner) for saving 5 bytes [Try it online](http://retina.tryitonline.net/#code=VGBsYEwKIHwoQU5EfE9SfEJZfE9GKVxifFxCLgo&input=TGlnaHQgQW1wbGlmaWNhdGlvbiBieSAgIFN0aW11bGF0aW9uIG9mIEVtaXR0ZWQgUmFkaWF0aW9u) ``` T`l`L # Replace lowercase with uppercase \|(AND\|OR\|BY\|OF)\b\|\B. # Regex match, it doesn't matter if we match 'AND' in SHAND # since the 'SH' will still become 'S' or am I missing something? # Replace with nothing ``` [Answer] ## vim, 46 ``` gUU:s/ /\r/g<cr>:g/\vAND\|OR\|OF\|BY/d<cr>:%s/.\zs.\n<cr> ``` ``` gUU make line uppercase :s/ /\r/g<cr> replace all spaces with newlines :g/\vAND\|OR\|OF\|BY/d<cr> remove unwanted words :%s/.\zs.\n<cr> remove all non-initial characters and newlines ``` I particularly like that last bit. The first `.` in the regex matches the first character of the line. Then we use `\zs` to start the "actually-being-replaced" part, effectively not replacing the initial character. `.` matches the rest of the line, and `\n` matches the trailing newline. Since we don't specify a replace string, vim simply removes everything in the match, leaving only initials. [Answer] # JavaScript (ES6), 56 bytes Saved a byte thanks to @edc65. ``` s=>s.toUpperCase().replace(/\B.\| \|(AND\|O[RF]\|BY)\b/g,"") ``` ## Explanation The code is self explanatory, I'll just explain the regex: ``` \B. // Matches any character (`.`), that's not the start of a word \| // Matches spaces \|(...)\b // Matches all the words that should be ignored ``` It removed all of these matched characers and uppercases the word [Answer] # JavaScript, ~~61~~ ~~64~~ ~~66~~ 63 bytes ``` a=>a.toUpperCase().replace(/(AND\|O[FR]\|BY\|(\w)\w+)( \|$)/g,"$2") ``` It uses a Regular Expression to find get words that aren't from the list: `and, or, of, by`, and captures the first letter. It then capitalizes the resulting string of letters. EDIT:* 64 Bytes - Fixed for words start with `of,or,by,and` EDIT: 66 Bytes - Fixed to check all words including last word. EDIT: 63 Bytes - Saved 3 Bytes thanks to [@edc65](https://codegolf.stackexchange.com/users/21348/edc65) and [@Cyoce](https://codegolf.stackexchange.com/users/41042/cyoce)! [Answer] # CJam, ~~28~~ ~~24~~ 22 bytes ``` qeuS/"AOBONRYFD"4/z-:c ``` [Try it online](http://cjam.aditsu.net/#code=qeuS%2F%22AOBONRYFD%224%2Fz-%3Ac&input=Light%20Amplification%20by%20Stimulation%20of%20Emitted%20Radiation). Thanks to Sp3000 for pointing out a bug and suggesting a fix, and to Dennis for saving ~~4~~ 6(!) bytes. ### Explanation ``` qeuS/ e# Convert the input to uppercase and split on spaces "AOBONRYFD"4/z e# Push the array of short words. See more below - e# Remove each short word from the input words :c e# Cast the remaining words to characters, which is a e# shorter way of taking the first letter ``` Dennis suggested this trick for shortening the word list: Splitting `AOBONRYFD` into chunks of four, we get ``` AOBO NRYF D ``` Transposing columns into rows with the `z` operator, we get the proper words! [Answer] # Julia, ~~72~~ ~~63~~ ~~61~~ 55 bytes ``` s->join(matchall(r"\b(?!AND\|OR\|OF\|BY)\S",uppercase(s))) ``` This is an anonymous function that accepts a string and returns a string. To call it, assign it to a variable. We convert the string to `uppercase`, select each match of the regular expression `\b(?!AND\|OR\|OF\|BY)\S` as an array, and `join` it into a string. Saved 8 bytes thanks to Dennis! [Answer] ## Perl, 32 bytes ``` say uc=~/\b(?!AND\|OR\|OF\|BY)\S/g ``` +1 byte for the `-n` flag. Algorithm stolen from [@AlexA's Julia answer](https://codegolf.stackexchange.com/a/75463/3808). [Answer] # Ruby, ~~45~~ 43 bytes ``` ->s{s.upcase.scan(/\b(?!AND\|OR\|OF\|BY)\S/)''} ``` This is a lambda function that accepts a string and returns a string. To call it, assign it to a variable and do `f.call(input)`. It uses the same approach as my [Julia answer](https://codegolf.stackexchange.com/a/75463/20469), namely convert to uppercase, get matches of the regular expression `\b(?!AND\|OR\|OF\|BY)\S`, and join into a string. [Try it here](https://repl.it/BviG/1) Saved 2 bytes thanks to manatwork! [Answer] ## Python, 81 bytes ``` lambda s:''.join(c[0]for c in s.upper().split()if c not in'AND OF OR BY'.split()) ``` [Answer] # PHP, 92 bytes First attempt at code golf. ``` foreach(explode(" ",str_replace(["AND","OR","BY","OF"],"",strtoupper($s)))as$x){echo$x[0];} ``` The variable `$s` is the phrase to be converted: `$s = "United States of America"`. Requires PHP 5.4 or above for short array syntax to work. [Answer] # Bash + GNU coreutils, ~~103~~ 76 bytes ``` for i in ${@^^};do grep -qE '\b(AND\|OR\|BY\|OF)\b'<<<$i\|\|echo -n ${i:0:1};done ``` Run with ``` ./codegolf.sh Light Amplification BY Stimulation of Emitted Radiationofo ``` either with single argument quoted or with multiple arguments. (I distorted the last word to contain of). --- # 60 bytes Thanks to @manatwork. ``` for i in ${@^^};{ [[ $i = @(AND\|OR\|BY\|OF) ]]\|\|printf %c $i;} ``` [Answer] # JavaScript, ~~104~~ 85 bytes Saved 19 bytes thanks to @Aplet123. Splits the string by spaces then checks if it is the words of, or, and, or by. If it is, it ignores it, otherwise it takes the first letter of it. It then joins the array and makes the string uppercase. ``` a=_=>_.split` `.map(v=>/\b(o(f\|r)\|and\|by)\b/i.test(v)?"":v[0]).join("").toUpperCase() ``` Ungolfed: ``` function a(_) { _ = _.split` `; //Split on spaces _ = _.map(function(v){return new RegExp("\b(o(f\|r)\|and\|by)\b","i").test(v)}); //Check if the banned words are in the result _ = _.join(""); //Join it into a string _ = _.toUpperCase(); //Convert it to uppercase }; ``` [Answer] # [MATL](https://esolangs.org/wiki/MATL), ~~34~~ 27 bytes 1 byte fewer thanks to @AandN* ``` KkYb'OF AND OR BY'YbX-c1Z)! ``` [Try it online!](http://matl.tryitonline.net/#code=WGtZYidPRiBBTkQgT1IgQlknWWJYLWMxWikh&input=J1VuaXRlZCBTdGF0ZXMgT2YgQW1lcmljYSc) ``` Xk % convert to uppercase Yb % split by spaces. Gives a cell array of input words 'AND OR BY OF' % ignored words separated by spaces Yb % split by spaces. Gives a cell array of ignored words X- % setdiff: remove ignored words (result is stable) c % convert to 2D char array, padding words with spaces 1Z) % take first column ! % transpose into a row ``` [Answer] # [05AB1E](http://github.com/Adriandmen/05AB1E), ~~33~~ ~~32~~ 28 bytes Code: ``` ‘€ƒ€—€‚€‹‘ð¡)Uuð¡)vXyQO>iy¬? ``` Uses CP-1252 encoding. [Answer] # Haskell, ~~100~~ ~~99~~ ~~98~~ ~~82~~ 75 bytes ~~I am quite sure it can be shortened a lot more as I still suck at using `$`,`.` etc. so I keep using `()` insted=)~~ Thanks @nimi for your help magic! ``` import Data.Char w=words x=[h!!0\|h<-w$toUpper<$>x,notElem h$w"OF BY OR AND"] ``` Example: ``` Main> a "united states by america" "USA" ``` [Answer] # Python, 103 96 bytes This is my first attempt at code golf, and this could probably be golfed a lot more. Thanks to DenkerAffe for saving seven characters. ``` lambda x:"".join([x[0]for y in x.split(" ") if y.lower() not in ['and','or','of','by']]).upper() ``` It takes the input, turns it into a list of words and takes their first letter if it's not one of the forbidden words, then turns everything to uppercase. [Answer] # JavaScript, ~~80~~ ~~72~~ ~~55~~ 53 bytes ## Code ``` function a(t){t=t.toUpperCase();t=t.replace(/AND\|OR\|BY\|OF\|\B.\| \|/g,"");return t} ``` ``` function a(t){return t.toUpperCase().replace(/AND\|OR\|BY\|OF\|\B.\| \|/g,"")} ``` I just read about arrow functions and realized I could shorten this up even more. ``` a=t=>t.toUpperCase().replace(/AND\|OR\|BY\|OF\|\B.\| \|/g,"") ``` According to [this](http://meta.codegolf.stackexchange.com/questions/6915/how-do-we-calculate-the-length-of-lambda), you don't count the assignment in the length, so -2 bytes. ``` t=>t.toUpperCase().replace(/AND\|OR\|BY\|OF\|\B.\| \|/g,"") ``` This is my first golf, so it's not very good. [Answer] # PHP, ~~68~~ ~~61~~ 58 bytes Uses ISO-8859-1 encoding. ``` for(;$w=$argv[++$x];)stripos(_AND_OR_BY_OF,$w)\|\|print$w&ß; ``` Run like this (`-d` added for aesthetics only): ``` php -d error_reporting=30709 -r 'for(;$w=$argv[++$x];)stripos(_AND_OR_BY_OF,$w)\|\|print$w&ß; echo"\n";' united states oF america ``` Ungolfed: ``` // Iterate over the CLI arguments (words). for(;$w = $argv[++$x];) // Check if the word is one of the excluded words by substring index. // The check is case insensitive. stripos("_AND_OR_BY_OF", $w) \|\| // Print the word, converting to uppercase and getting only the // first char by using bitwise AND. print $w & "ß"; ``` Saved 7 bytes by using bitwise AND instead of using `ucwords`. * Saved 3 bytes by using ISO-8859-1 encoding and using `ß` (binary `11011111`) for binary `AND` instead of a negated space (binary `00100000`). [Answer] # [R](https://www.r-project.org/), ~~77~~ 75 bytes ``` cat(substr(w<-toupper(scan(,'')),1,1)[!grepl('^(AND\|OR\|OF\|BY)$',w)],sep='') ``` [Try it online!](https://tio.run/##DcrBCsIwDADQX6kgNIV42F0Pinh04G0MhdhFGWhXkpRd@u/Vd37SWiQDLU81gXW/s6XkzAIaKQF6HwJ22IVx8xbOH/APOF7Ptb/V/lJPQ9h6XMMdlfPhf1tJs/Hk1MhY3fJylCZHX5Y5UvsB "R – Try It Online") -1 byte thanks to [Dominic van Essen](https://codegolf.stackexchange.com/users/95126/dominic-van-essen) changing the indexing. Reads from stdin. Takes the words, converts them to uppercase, removes those that are excluded from acronyms, extracts the first character from each, and prints them to the stdout. [Answer] # [K (ngn/k)](https://bitbucket.org/ngn/k), 34 bytes ``` {`c$-32+'(" "\_x)^$`and`or`by`of} ``` [Try it online!](https://tio.run/##PYzLCsIwFER/5RIKWqUb3enKhRsRBEXciCZtkvZiHpLegkX89hgtdDkzZ86jcLWLUa/evMqK5WI@m0wZsOv9ld8yLpzkPvCy515/ok7T2SEpCScSpFrwGjZWBawEW7M91g2l/DSoU0PoHZR9QtF2ZoiJ31qkn@EoJP7L9OwGaTtKxSjd@SCFg4MGahRcfDCS5fEL "K (ngn/k) – Try It Online") `_x` lowercase the input * `(" "\...)` split input on spaces * `(...)^$`and`or`by`of` remove and/or/by/of * `'` take the first character of each remaining word ``c$-32+` convert to uppercase [Answer] # Mathematica, ~~132~~ 117 bytes ``` ToUpperCase[First/@Characters@DeleteCases[StringDelete[StringSplit@#,"of"\|"and"\|"or"\|"by",IgnoreCase->True],""]<>""]& ``` 15 bytes saved thanks to @CatsAreFluffy. [Answer] # PowerShell, 81 Bytes ``` (-join($args[0].Split(" ")\|?{$_-notmatch"^(and\|or\|by\|of)$"}\|%{$_[0]})).ToUpper() ``` --- Explanation Split on the spaces creating an array. Drop the offending members. Pull the first character and join together. Use `ToUpper()` on the resulting string. [Answer] ## Lua, 122 Bytes I would have love to use a pattern to get rid of the banned words, but sadly, lua isn't made to match groups of characters... So I had to use a for loop instead, which is much more expensive. ``` s=arg[1]for k,v in next,{"of","and","by","or"}do s=s:gsub(v,"")end print(s:gsub("(%a)%a+",string.upper):gsub("%s","").."") ``` ### Ungolfed ``` s=arg[1] -- initialise s with the argument for k,v in next,{"of","and","by","or"} -- iterate over the array of banned words do s=s:gsub(v,"") -- replace the occurences of v by end -- an empty string print(s:gsub("(%a)%a+", -- replace words (separated by spaces) string.upper) -- by their first letter capitalised :gsub("%s","") -- replace spaces with empty strings .."") -- concatenate to prevent the number of -- substitutions to be shown ``` [Answer] # Factor, 175 bytes I learned a lot by writing this. ``` USING: strings ascii sets splitting kernel sequences math.ranges ; >lower " " split [ { "and" "or" "by" "of" } in? not ] filter [ first dup [a,b] >string ] map "" join >upper ``` As a word: ``` USING: strings ascii sets splitting kernel sequences math.ranges ; : >initialism ( str -- str ) >lower " " split ! string.lower.split(" ") [ { "and" "or" "by" "of" } in? not ] filter ! word in { } ? [ first dup [a,b] >string ] map ! word[0] "" join >upper ; ! "".join.upper ``` Unit tests: ``` USING: tools.test mk-initialism ; IN: mk-initialism.tests { "LASER" } [ "Light Amplification by Stimulation of Emitted Radiation" >initialism ] unit-test { "USA" } [ "United States OF Americaof" >initialism ] unit-test { "USA" } [ "united states and america" >initialism ] unit-test { "JTW" } [ "Jordan Of the World" >initialism ] unit-test ``` Pass! [Answer] # Lua, ~~113~~ ~~112~~ 93 bytes ``` arg[1]:upper():gsub("%w+",function(w)io.write(("AND OR BY OF"):find(w)and""or w:sub(0,1))end) ``` [Answer] # C#, 134 bytes Golfed ``` class P{static void Main(string[] a){foreach (var s in a){if(!"AND OR BY OF".Contains(s.ToUpper())){Console.Write(s.ToUpper()[0]);}}}} ``` Readable ``` class P { static void Main(string[] a) { foreach (var s in a) { if (!"AND OR BY OF".Contains(s.ToUpper())) { Console.Write(s.ToUpper()[0]); } } } } ``` Execute from command line 75448.exe Light Amplification by Stimulation of Emitted Radiation > > LASER > > > 75448.exe united states of america > > USA > > > [Answer] # [Husk](https://github.com/barbuz/Husk), ~~19~~ 18 bytes ``` m←¤-w¨BYΘRΘF⁴ND¨ma ``` [Try it online!](https://tio.run/##ATcAyP9odXNr//9t4oaQwqQtd8KoQlnOmFLOmEbigbRORMKobWH///9Kb3JkYW4gT2YgdGhlIFdvcmxk "Husk – Try It Online") -1 byte from Dominic Van Essen. [Answer] # [Stax](https://github.com/tomtheisen/stax), ~~16~~ 12 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax) ``` î♣}ïû┴N=a,╥Ç ``` [Run and debug it](https://staxlang.xyz/#p=8c057d8b96c14e3d612cd280&i=United+States+of+America%0ALight+Amplification+by+Stimulation+of+Emitted+Radiation%0Aunited+states+of+america%0AJordan+Of+the+World&m=2) ]
[Question] [ Inspired by this Stack Overflow question: [Sorting a list: numbers in ascending, letters in descending](https://stackoverflow.com/questions/45541119/sorting-a-list-numbers-in-ascending-letters-in-descending). Your task is to solve the following problem and, as this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), you should do so in as few as bytes as possible. You should take a list of objects as input containing letters (any reasonable form: `string`, `char`, etc) and numbers. You should then sort the numbers into ascending order and the letters into descending order. However, you should keep letters in letter positions and numbers in number positions. For example, if the list is: ``` [L, D, L, L, D, L] ``` The output list should be in the form of: ``` [L, D, L, L, D, L] ``` Workthrough Input: `['a', 2, 'b', 1, 'c', 3]` * Sort the numbers into ascending order: `[1, 2, 3]` * Sort the letters into descending order: `['c', 'b', 'a']` * Join them back but keep the order the same: `['c', 1', 'b', 2, 'a', 3]` Rules * The list will only contain letters and digits. * The list may be empty. * The list may only contain letters or only digits. * If your language does not support mixed type arrays you may use digit characters instead of numbers. Note that if your language does support this you must use mixed types. * Letters will only be `[a-z]` or `[A-Z]`, you may choose which one. * Letters are sorted as `a` being lowest, `z` being highest i.e. `a = 1, z = 26`. * [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden. * I/O may be by any standard means including as a string. Test cases ``` [5, 'a', 'x', 3, 6, 'b'] -> [3, 'x', 'b', 5, 6, 'a'] [ 3, 2, 1] -> [ 1, 2, 3 ] [ 'a', 'b', 'c' ] -> [ 'c', 'b', 'a' ] [] -> [] [ 2, 3, 2, 1 ] -> [1, 2, 2, 3] ``` As this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") the shortest answer in bytes wins! [Answer] # [Python 2](https://docs.python.org/2/), ~~53~~ ~~52~~ 51 bytes -2 bytes thanks to g.rocket -1 byte thanks to Jonathan Frech -1 byte thanks to RootTwo ``` def F(x):n=sorted(x);print[n.pop(-(e>x))for e in x] ``` [Try it online!](https://tio.run/##NY0xDsIwDEV3TuEtieQiEQRDKzr2ElEGSlPRxYnSDOH0wS5i@Xr/68lOn/KOZFtbwgqTrqanxx5zCQvzkPJGxdE5xaQ7HcZqzBozBNgIqm/CJexFqnM3BPVUHJXjinBnnJVHJ8UiXAR/xizxUsCLjBb/Cnjfn@B4e1xmrRtZHiYt1bQv "Python 2 – Try It Online") The `sorted` list will have the numbers first and then the chars like `[3, 5, 6, 'a', 'b', 'x']`, then use `e>x` to filter what is number and what is char, in python any number is less than a list (input) and a list is less than a string. [Answer] # [Retina](https://github.com/m-ender/retina), 10 bytes ``` O`\d O^`\D ``` [Try it online!](https://tio.run/##K0otycxL/P/fPyEmhcs/LiHG5f//RKMkw2RjAA "Retina – Try It Online") The `O` stage in Retina can directly perform the kind of selective sorting required by this challenge. Here the first line sorts digits while the second line sorts non-digits in reverse. [Answer] # [APL (Dyalog)](https://www.dyalog.com/), ~~27~~ 26 bytes Expects characters to be uppercase ``` (⍋⊃¨⊂)@(~e)(⍒⊃¨⊂)@(e←∊∘⎕A) ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R2wSNR73dj7qaD6141NWk6aBRl6oJFJmEJJIKVPSoo@tRx4xHfVMdNYG6FEx1FNQd1YFEBJAw1lEwAzKd1LnSQGwjHQVDIAsi7wQinEEyj3rXAAA "APL (Dyalog Unicode) – Try It Online") This is just two applications of the form `f@g`, apply the function `f` on the items indicated by `g`. For the first application we use: `f`: `⍒⊃¨⊂` the descending grades (`⍒`) each pick (`⊃¨`) from the entire argument (`⊂`). `g`: `(e←∊∘⎕A)` members (`∊`) of (`∘`) the Alphabet (`⎕A`), and store (`←`) this function as `e`. For the second application we use: `f`: `⍋⊃¨⊂` the ascending grades (`⍋`) each pick (`⊃¨`) from the entire argument (`⊂`). `g`: `(~e)` not (`~`) members of the alphabet (`e`; the function we stored before) [Answer] ## JavaScript (ES6), ~~71~~ ~~51~~ 47 bytes Saved 20 bytes by just using `sort()`, as suggested by [@JustinMariner](https://codegolf.stackexchange.com/users/69583/justin-mariner) Saved 4 more bytes thanks to [@CraigAyre](https://codegolf.stackexchange.com/users/68610/craig-ayre) Using a similar approach as [Rod's Python answer](https://codegolf.stackexchange.com/a/138208/58563): ``` a=>[...a].map(n=>a.sort()[1/n?'shift':'pop']()) ``` ### Test cases ``` let f = a=>[...a].map(n=>a.sort()[1/n?'shift':'pop']()) console.log(JSON.stringify(f(['a', 2, 'b', 1, 'c', 3]))) // -> ['c', 1', 'b', 2, 'a', 3] console.log(JSON.stringify(f([5, 'a', 'x', 3, 6, 'b']))) // -> [3, 'x', 'b', 5, 6, 'a'] console.log(JSON.stringify(f([3, 2, 1]))) // -> [ 1, 2, 3 ] console.log(JSON.stringify(f(['a', 'b', 'c']))) // -> [ 'c', 'b', 'a' ] console.log(JSON.stringify(f([]))) // -> [] console.log(JSON.stringify(f([2, 3, 2, 1]))) // -> [1, 2, 2, 3] ``` [Answer] # [R](https://www.r-project.org/), ~~83~~ 76 bytes -7 bytes thanks to Miff ``` function(n){u=unlist d=n%in%0:9 n[d]=sort(u(n[d])) n[!d]=sort(u(n[!d]),T) n} ``` This is the same as the below, but it allows for mixed-type input as a `list` rather than an `atomic` vector (which would typecast everything as characters with mixed types). [Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jT7O61LY0LyezuIQrxTZPNTNP1cDKkisvOiXWtji/qESjVAPE1tQECikiiwE5mjohQOHa/2kaIO0aSolKOkY6SklKOoY6SslKOsaamv8B) # [R](https://www.r-project.org/), ~~68~~ 61 bytes -7 bytes thanks to Miff ``` function(n){d=n%in%0:9 n[d]=sort(n[d]) n[!d]=sort(n[!d],T) n} ``` Anonymous function. All digits are cast to characters in this case. `n[-d]` is the array without the digits. Returns `NULL` (empty list) on empty input. [Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jT7M6xTZPNTNP1cDKkisvOiXWtji/qEQDxNIE8hURAkCmTghQrPZ/mkayhlKiko6RjlKSko6hjlKyko6xpiYXSFxT8z8A) [Answer] # [Japt](https://github.com/ETHproductions/japt), ~~18~~ 15 bytes Thanks @Shaggy for -3 bytes and for help fixing for arrays with `0`s. ``` c ñc ®¤?Vv :Vo ``` First line is intentionally left blank. [Try it online!](https://codepen.io/justinm53/full/NvKjZr?code=CmMg8WMKrqQ/VnYgOlZv&inputs=WzUsICdhJywgJ3gnLCAzLCA2LCAnYidd,WzMsIDIsIDFd,WydhJywgJ2InLCAnYydd,W10=,WydzJywgNSwgJ2EnLCAneCcsIDMsIDAsIDYsICdiJ10=&flags=LVE=) using `-Q` to view the formatted array. ## Explanation First line is blank to avoid overwriting the input array. `[5, 'a', 'x', 3, 6, 'b']` ``` c ñc ``` Make a copy by flattening (`c`) the input array, then sort (`ñ`) with strings represented by their char code (`c`). This is stored in `V`. `[3, 5, 6, 'a', 'b', 'x']` ``` £ ``` Then map the input array by the function... ``` ¤?Vv :Vo ``` Turn numbers into binary strings (truthy) or strings into `""` (falsy) (`¤`). If truthy, remove from the start of `V` (`v`), otherwise remove from the end (`o`). [Answer] # JavaScript, ~~164~~ ~~162~~ ~~158~~ 142 bytes edit 1: 2 bytes less after removing a redundant assignment of v. edit 2: 4 bytes less thanks to TheLethalCoder. edit 3: 16 bytes less thanks to brilliant hints from Justin Mariner ``` x=>eval("n=v=>typeof(v)=='number';l=x.length;for(i=0;i<l;x[i++]=x[m],x[m]=w){for(v=w=x[j=m=i];++j<l;)n(e=x[j])==n(w)&&e<v==n(w)&&(m=j,v=e)}x") ``` It's my very first time in code-golf, so it can surely be improved... But still, worth a try. The program performs a variant of selection sort, which only takes into account the values of the same type as the current one (swapping only a number and a number, or a letter and a letter) Readable form: ``` x=>eval(" n=v=>typeof(v)=='number'; l=x.length; for(i=0;i<l;x[i++]=x[m],x[m]=w){ for(v=w=x[j=m=i];++j<l;) n(e=x[j])==n(w) && e<v==n(w) && (m=j,v=e) } x ") ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes ``` OÞḢṪOƑ}?Ɱ ``` [Try it online!](https://tio.run/##y0rNyan8/9//8LyHOxY93LnK/9jEWvtHG9f9dzvcfnTSw50zNCP//4821VFQT1QHEhVAwlhHwQzITFKP1VGIBvGMdBQMwWyImiQQkayuABICCxvpwFQpxAIA "Jelly – Try It Online") Takes input as a flat array (Jelly typically treats strings as char arrays, so `[5, 'a', 'x', 3, 6, 'b'] -> [5, ['a'], ['x'], 3, 6, ['b']]`. The Footer flattens this array for you). Similar to [PurkkaKoodari](https://codegolf.stackexchange.com/users/30164/purkkakoodari)['s Jelly answer](https://codegolf.stackexchange.com/a/138213/66833) ## How it works ``` OÞḢṪOƑ}?Ɱ - Main link. Takes an array A on the left Þ - Sort by: O - Ordinal This shuffles the strings to the end, sorting both the strings and the numbers Ɱ - Over each element E in A: ? - If statement: OƑ} - Condition: E is a number? Ḣ - Then: Pop and yield the first element of A sorted Ṫ - Else: Pop and yield the last element of A sorted ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 14 bytes ``` FOÞɓṪ}Ḣ}ẇØa$?€ ``` [Try it online!](https://tio.run/##y0rNyan8/9/N//C8k5Mf7lxV@3DHotqHu9oPz0hUsX/UtOb////RpjoK6onqQKICSBjrKJgBmUnqsQA "Jelly – Try It Online") Basically a port of [Rod's Python solution](https://codegolf.stackexchange.com/a/138208/30164). [Answer] # q/kdb+, ~~54~~ 53 bytes Solution: ``` {x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x} ``` Examples: ``` q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}(5;"a";"x";3;6;"b") / mixed list 3 "x" "b" 5 6 "a" q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}3 2 1 / simple list 1 2 3 q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}"abc" / simple list "cba" q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}2 3 2 1 / simple list 1 2 2 3 ``` Explanation: Find the chars in the list, sort descending, find the longs in the list, sort them ascending, join to get a list of, e.g. `("x";"b";"a";3;5;6)`, then assign the sorted values back to their original positions in the list, e.g. at `0 3 4 1 2 5`. Golfing is just switching out q keywords (`each`, `where` and `not`) for their `k` equivalent (which requires them to be wrapped in brackets). ``` {x[w,q]:asc[x w:where d],desc x q:where not d:-7=type each x;x} / ungolfed { ; } / lambda function with 2 statements type each x / return types of elements in mixed list -7= / true where item is a long d: / save this bool array in d not / invert where / indices where true (we have chars) q: / save these indices in q x / values of x at these indices desc / sort them descending , / join/contatenate where d / indices where we have digits w: / save this in w x / values of x at these indices asc[ ] / sort them ascending x[w,q]: / assign this list to x at indices w,q x / return x ``` Edits * -1 byte as don't need square brackets around `desc` [Answer] # [C++17 (gcc)](https://gcc.gnu.org/), 219 bytes ``` #include <variant> #include <set> using V=std::variant<char,int>;void f(Va,Vb){std::set<V>S[2];for(Vc=a;c<b;++c)S[c->index()].insert(c);auto C=S->rbegin();auto N=S[1].begin();for(;a<b;++a)a=(a->index()?N++:C++);} ``` [Try it online!](https://tio.run/##bZBNa4NAEIbv/oohhcZ1NZCWtuCqPeSei@DFehjXjy6YNegqKeJfr101bVPoHIbdmXee@eDns1NyPk13QvKqy3LwemwEShUYv6E219@uFbKEyG9V5rpXkcffsbGFVrO@FhkUZmShHVkpGRaZLvSiIIwfElbUjU5yHxn3UkYpJ2HMnUDILL@YJNkJ2eaNMi1OGHaqNg5@6ARNmpdCmmsIjn4Y75Pdd2wmMlxgSCz0TfzBvVpHSl3rQClh43Sziahb1eR4ut2uU6IS6iMw9B5wwpkNgwHaIshQYZyADwM82bDFrXYX7R5teNbPdAsjW6SFCetccwWxIZfZ@gSyCpZ78LpT4HmwGWBzrasbMHktWwXRPfTgLi3JkputF61QJsTJVTQfQuuw0jP@ZerYgtZkGG2N@rfx@CZ159GYPnlRYdlOjs77nNL9yxc "C++ (gcc) – Try It Online") Hardly competitive. But I must support mixed-type arrays? FINE. Accepts an array of variants in range style, and modifies it in place. Copies the input into two sorted sets, and then back into the input/output array. [Answer] # [Japt](https://github.com/ETHproductions/japt), 9 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) I knew* there had to be a (golfy) way to do this without any sort of conditional :) Outputs an array of singleton arrays. Replace `£` with `c@` to output a flat array. ``` £=ñs)jÓXÌ ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=oz3xcylq01jM&input=WzUgImEiICJ4IiAzIDYgImIiXQotUQ) ``` £=ñs)jÓXÎ :Implicit input of array U £ :Map each X (or flat map with c@) = : Reassign to U ñ : Sort by s : Converting to string if an integer, slicing if a string (which does nothing to the string if given no arguments) ) : End reassignment j : Remove (mutating the original) and return the element at modular 0-based index Ó : Bitwise NOT of the negation of (i.e, decrement) XÎ : Sign of difference of X with -1 if an integer, last character if a string (resulting in 0 if an integer or -1 if a string) ``` [Answer] # Mathematica, 203 bytes ``` (K=Reverse;B=Complement;L=Length;S=Position[#,_Integer];T=Sort@Cases[#,_Integer];G=K@B[#,T];V=B[Range@L@#,Flatten@S];R=K@Sort@#;Table[R[[Min@S[[i]]]]=T[[i]],{i,L@T}];Table[R[[V[[i]]]]=G[[i]],{i,L@G}];R)& ``` [Try it online!](https://tio.run/##VYvBasMwDEDv@4rhwOhAl620FyMwKSyMZlAc04sxxSlqakicEZsxKPn21ARGF4FAvPfU2Xh15zBdcFrtUdIPDYF4jru@@26pIx95iSX5Jl55hYc@uOh6rzM4ffpIDQ2GK6z6IYqdDRQWosC9yBNRhh8x19L6hkQpMvhobYzkRWW4TM38nnFl65a01PrLJaW1M2lQzQfcHJRCjeZRHf@K4l9RpEK@vkyHwfn4LC76tgFmGbBfBmvYAqvZaJ4ednZ12vOSr@Ed3hZkNNMd "Mathics – Try It Online") [Answer] # [Pyth](https://pyth.readthedocs.io), ~~12~~ 11 bytes ``` KSQm.(Kt>\@ ``` [Try it online!](https://pyth.herokuapp.com/?code=KSQm.%28Kt%3Cd%5C%40&input=%5B%275%27%2C+%27a%27%2C+%27x%27%2C+%273%27%2C+%276%27%2C+%27b%27%5D&test_suite_input=%5B%275%27%2C+%27a%27%2C+%27x%27%2C+%273%27%2C+%276%27%2C+%27b%27%5D%0A%5B+%27a%27%2C+%27b%27%2C+%27c%27+%5D%0A%5B%5D&debug=0) or [Try the Test Suite.](https://pyth.herokuapp.com/?code=KSQm.%28Kt%3E%5C%40&test_suite=1&test_suite_input=%5B%275%27%2C+%27a%27%2C+%27x%27%2C+%273%27%2C+%276%27%2C+%27b%27%5D%0A%5B+%27a%27%2C+%27b%27%2C+%27c%27+%5D%0A%5B%5D&debug=0) --- # Explanation ``` KSQm.(Kt<d\@ - Full program with implicit input. KSQ - Assign a variable K to the lexicographically sorted input. m - Map over the input (with a variable d). .(K - Pop the sorted list at this location: >\@ - If d is lexicographically lower than '@', at 0 (the first element). Else, at -1 (the last element). ``` [Answer] # Python, ~~145~~ ~~139~~ 130 bytes 6 bytes saved thanks to @officialaimm 9 bytes saved thanks to @Chris\_Rands ``` g=lambda s,a:sorted(x for x in s if(type(x)==str)==a) def f(s):l,n=g(s,1),g(s,0)[::-1];return[[n,l][type(x)==str].pop()for x in s] ``` [Try it online!](https://tio.run/##TY7LDsIgEEXX8hWzKySjsRpdYPBHCAu0RZsgJYAJfn2d1kTd3HncM4/4Kvcx7Kfpprx9XDoLGa3MYyp9xyu4MUGFIUCGwfHyij2vQqlcEqkVrOsdOJ6F9BjUjWdsBc5hK7SU69acUl@eKWgd0Bv9P282cYxc/A6YyYMCzVb6gNDYhqSS7BGOlF4ag2Qt/d1SI7QUrzOyWDNJTvspPgtmihBYeoYZ9j3nJVvFNITCKyHqTKCj18T0Bg) [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 17 bytes ``` SaJ¹á{R¹þ{«vyay.; ``` [Try it online!](https://tio.run/##MzBNTDJM/f8/ONHr0M7DC6uDgOS@6kOryyoTK/Ws//9Pqyw1sTDLtLQwBwA "05AB1E – Try It Online") --- ``` SaJ # Push 1 if letter 0 else, for all letters in string. ¹á{R # Reverse sort letters from input. ¹þ{ # Regular sort digits from input. « # Concatenate those two things. v # For each letter in the sorted string... ya # 0 if digit, 1 if letter. y.; # Replace first instance of 0/1 with digit/letter. ``` --- Using the sort-by closure actually was worse: `Σ©Ç®ai0<}}¹SaJsvyay.;` [Answer] ## Haskell, 108 bytes There may be shorter ways, but I just had to try it with the `Lens` library. ``` import Control.Lens import Data.List i(!)f=partsOf(traverse.filtered(!'='))%~f.sort f x=x&i(<)id&i(>)reverse ``` I could define `f` to just be the composition of the two `i` invocations, but I'd still have to apply `x` to it to avoid a type error from the monomorphism restriction. Note that the type of `f` is `Traversable t => t Char -> t Char` so it can be used with `String`s which are lists of `Char`s as well as with arrays of `Char`s. Here are the test cases: ``` Main> map f ["5ax36b","321","abc","","2321"] ["3xb56a","123","cba","","1223"] ``` [Answer] # Python 3, 77 bytes This answer is based on the comment that says you can use '1', '2', etc if chars and digits are not comparable in the language. 'a' and 1 are not comparable in Python 3. ``` def f(s):x=sorted(s,key=lambda c:ord(c)-95);return[x.pop(-(c>'.'))for c in s] ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), 125 113 110 bytes ``` main(i){charb,c,s[99];for(gets(c=b=s);++c\|\|(c=++b);)i=b&64,i^c&64\|\|c>b^!i&&(i=c,c=b,b=i);puts(s);} ``` [Try it online!](https://tio.run/##FczBCsIwEIThu2/hJWQ38aQWSoigTyGIhe6gdQ9VafRkffa4nobhhw@rAah17PXulT649RNLZMRyattzuj4mP1xexSNLLpQ4BMwz2w1BKJFmFtdsonYMW0vYsXRLdc5bg0n570lWSs@3QYZ8a93uj@vmsPgB "C (gcc) – Try It Online") Explained: ``` main(i) { charb,c,s[99]; // slightly modified stupid bubblesort, this line in fact // does nested looping with a single for statement for(gets(c=b=s);++c\|\|(c=++b);) // (undefined behavior here, there's no sequence point between accesses to c, // so this could go wrong. Works with the gcc version on tio.) // determine whether the current b is a letter: i=b&64, // for doing anything, b and c must be the same "type": i^c&64 // when c > b for letter or c <= b for digit \|\| c>b^!i // then swap && (i=c,c=b,b=i); puts(s); } ``` Letters are expected in uppercase. [Answer] # PHP, 66 bytes: ``` for($a=$argv,sort($a);a&$c=$argv[++$i];)echo$a[$c<A?++$k:--$argc]; ``` takes input from command line arguments, prints a string. Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/0db1a4c24000e852a95ab9e6ad87ec30ce45c924). Yields a warning in PHP 7.1; replace `a&` with `""<` to fix. [Answer] # [APL (Dyalog)](https://www.dyalog.com/), 26 bytes ``` a[⍒i][⍋⍋27>i←(⎕a,⌽⍳9)⍳a←⎕] ``` (uses `⎕IO=1`) [Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob2pm/qO2CYYgFpBWSIx@1DspMxZIdgORkbldJlBUAyiZqPOoZ@@j3s2WmkAiESgIFIv9/1/dUV1HwUhHQd0JSBsCaWcgbQwA "APL (Dyalog Classic) – Try It Online") [Answer] # [Uiua](https://uiua.org), 24 [bytes](https://codegolf.stackexchange.com/a/265917/97916) ``` ⍜▽(⊏⍏.)¬⊃∘⍜▽(⊏⍖.)⊐∵type. ``` [Try it!](https://uiua.org/pad?src=0_1_0__ZiDihpAg4o2c4pa9KOKKj-KNjy4pwqziioPiiJjijZzilr0o4oqP4o2WLiniipDiiLV0eXBlLgoKZiB7NSBAYSBAeCAzIDYgQGJ9CmYgezMgMiAxfQpmIHtAYSBAYiBAY30KZiB7MiAzIDIgMX0K) ``` ⍜▽(⊏⍏.)¬⊃∘⍜▽(⊏⍖.)⊐∵type. . # duplicate ⊐∵type # mask of types (0 for number, 1 for character) ⍜▽(⊏⍖.) # descending sort the characters ⊃∘ # keep the mask ¬ # not ⍜▽(⊏⍏.) # ascending sort the numbers ``` [Answer] # [K (ngn/k)](https://codeberg.org/ngn/k), 26 bytes ``` {x[>i]@<<1>i:x1 1'`c=@'x} ``` Derived from @ngn's APL solution [Try it online!](https://ngn.codeberg.page/k#eJxLs6quiLbLjHWwsTG0y7Sq0DJUMFRPSLZ1UK+o5eJKczDVUUpU0lGqUNIx1jHTUUpSAoqZKBgrmCsYKRgD2UpJiUUgMUUDANktEfw=) [Answer] # Mathematica, 107 bytes ``` (s=#;s[[p]]=Sort[s[[p=#&@@@s~($=Position)~_String]],#2~Order~#>0&];s[[c]]=Sort@s[[c=#&@@@s~$~_Integer]];s)& ``` [Answer] # [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 171 bytes ``` a=>{var b=a.Where(x=>x is int).ToList();b.Sort();int i=0,j=0;return a.Select(x=>b.Contains(x)?b[i++]:a.Except(b).OrderByDescending(y=>y).ToList()[j++]);} ``` Byte count also includes: ``` using System.Linq; ``` [Try it online!](https://tio.run/##jVJNb9swDL37VxC9REI8oR/oDnXlYVvToUCLHVKghyAHSWFWBY6USXLrIPBvz6R4q@ftkPJA0PTjE/lI5T8o63Bfe21@wHTrA67ZV1tVqIK2xrNvaNBpVWQDxL02P4ssM2KNfiMU/s5nuwyiqUp4D58PcZdJ5oMIWsGL1Qt4ENoQ@varByXLBl@3tVHX99qHaytXsasyh7uJqdfohKzwT7KEJfC94OXuRTiQXLCnZ3RIGl42oD1oEyh7tImH0EKyqXUpiGnQ/DRf8dPCYaidAcGmmKZPpTJKYULs1ZOGfpIzPR7PrwSbNAo3gUjKvrsFui/bG/QKzSIKRLa83PYvzVaxghbtvhjMlHrUZlMH4GDwFbohZvPZfAAbypLsbzDs4DKHkRhF10R3kcPHGMoRtPmxwog9z@HsHciOXyan3sN8HHGe988PsG0x3PwyHqZQz@SgVtSrk4wekWhJ9Jv8/SLYrXWTRNYALyFu1dsK2ZPTId4IjOEETigt/iMbAOPRI/kH1E/QRW3W7n8B "C# (.NET Core) – Try It Online") Explanation: ``` a => { var b = a.Where(x => x is int).ToList(); // Filter to only ints and transform to list b.Sort(); // Sort the list int i = 0, j = 0; // Create index counters return a.Select(x => // Replace each input element with b.Contains(x) ? // If it is in list b: b[i++] : // Get the next element from b a.Except(b) // Otherwise take input and filter out those in b .OrderByDescending(x=>x)// Order them z to a .ToList()[j++]); // Get the next element ``` [Answer] # [Perl 5](https://www.perl.org/), 107 + 1 (-n) = 108 bytes ``` y/][//d;@a=split/, /;@l=sort grep/\D/,@a;@d=sort grep/\d/,@a;@r=map{/\d/?pop@d:shift@l}@a;$"=", ";say"[@r]" ``` [Try it online!](https://tio.run/##TcmxDsIgFIXhVyHEpAv1tpouEuIdXH0C7IBSlQTLDbA0xlcXMS5OX85/aIp@KGWBUQNYiUYl8i6DYCDRqxRiZrc4EZwOINBItP/N/lpUD0PP79xTILS7dHfXjP5VzxVXXDAuk1m4xjjyUnRjGsE2gjXnal@9VLfjO1B2YU6lPQ7rru9KO38A "Perl 5 – Try It Online") [Answer] # [Ruby](https://www.ruby-lang.org/), 265 bytes ``` x.sort_by(&:to_s).select{\|a\| a.is_a?(String)}.zip(x.map.with_index {\|a, i\| a.is_a?(String) ? i : nil}.compact).each{\|a,i\| x[i] = a} x.sort_by(&:to_s).select{\|a\| a.is_a?(Integer)}.zip(x.map.with_index {\|a, i\| a.is_a?(Integer) ? i : nil}.compact).each{\|a,i\| x[i] = a} ``` [Try it online!](https://tio.run/##jc6xCoMwEIDhvU9xOBQFOWi7CeLcuaNIONOgBxolSWls9dnTdOjUxelfvuE3j3YJvqwTmeRwyiGh2EtsG3tugkc7GSfaJT0WbhI2Q6sGJd17pRUI2Qqq0pszrLtswxfPqceRZnyy6wXru/IQaQ78p6EChgI0DxvKaZxJugwVyf7rI/c1N1ACbYddD1ftVKfM3okf330RZvDhAw "Ruby – Try It Online") First timer here, My solution is definetly not the best one. But since this is my first answer, I thought in posting just for the fun of it. Looking foward to see better Ruby answers, to see what is the best approach. I hope I improve in future answers =) Readable ``` x = ["c", 1, "a", 3, "b", 2] b = x.map.with_index {\|a, i\| a.is_a?(Integer) ? i : nil}.compact s = x.map.with_index {\|a, i\| a.is_a?(String) ? i : nil}.compact o = x.sort_by(&:to_s).select{\|a\| a.is_a?(Integer)} d = x.sort_by(&:to_s).select{\|a\| a.is_a?(String)} d.zip s d.zip(s).each {\|a, i\| x[i] = a} o.zip b o.zip(b).each {\|a, i\| x[i] = a } p x ``` [Answer] # Python 3, 91 bytes ``` def f(s):x=sorted(s,key=lambda c:(type(c)==str,c));return[x.pop(-(type(c)==str))for c in s] ``` [Answer] ## Clojure, 151 bytes ``` #(map(fn[t c](nth((if(=(type 1)t)vec reverse)(sort((group-by type %)t)))(-(c t)1)))(map type %)(reductions(partial merge-with +)(for[i %]{(type i)1}))) ``` Example: ``` (def f #( ... )) (f [5 \a \x 3 6 \b]) ; (3 \x \b 5 6 \a) ``` This calculates the cumulative ~~sum~~ count of integers and characters, and uses it to lookup the correct element from a sorted list of corresponding type's elements. [Answer] # [Zsh](https://www.zsh.org/), 43 ~~55~~ ~~70~~ ~~95~~ bytes ``` b=(${(n)@});for i;echo $b[$[#i>64?--k:++j]] ``` [Try it online!](https://tio.run/##JYvBCoMwGIPvPkXQHiyiTJ0eJtt8DxG0YtWNrcNWGHN99u6HXZJ8Cfno2cmQ795E4sQ5ZHv45LXllVQrlmocZgUmGtYEy6U8XuP4foqiW9s6W01g9XfVFkGSJN2qO9Dn0RsNM49Qm3ltxvMkemQQSDEgx4G4oOZNuYQgymlNyX2fJPuj@wE) ~~[55bytes](https://tio.run/##NYvbCoMwGIPvfYqgIi2iTN28KRu@xxC04mljc7QVxqzP3v0wdpPkS8hHT25gfPNGEifPLNzYk1c7F8OiMAvGgvlSHjmPor6bFoTymiT32to/xfGtdrsYEVZW6R1BmqaN0g3o/2iNhpl6LKt5rcbzBrTIIZGhQ4ED8YmaN@USkqigNSP3fZL8h@4L)~~ ~~[70bytes](https://tio.run/##RYzdCoJAFITvfYpBRXaRLLW8kcL3EEFX/I0y3JVC3WffDnTRzcz5Zg6zyt60jG9WR2LElbkbe/JM87SdZgwpY85wS86ce15T9xNckfv@3aevN3eyY14d1kIX@/4vx8LotIOb7bPUcIIgKGdZguYelZJQfYNpUa9FWVaLChEEQtSIcSK@UPKhO4EgiqkNyW2bJPqh@QI)~~ ~~[95bytes](https://tio.run/##RYvLCoMwEEX3@YrBBkkIEh@t0Jq2/kfIIla0KrSgm2Kab08HsuhiZu45w923ZxgYdyNOsFdGHXvxVuo8OxvPof8bm@1oyPBeYWoYO0y3@ngXYrkIMXOepkop6qibYlfSXs/Gx5qkVi/GB9@MQNvvunlCBrBQQgcFPKCCHPmE5oO5hg6pwm@BN0lwlRHDDw "Zsh – Try It Online")~~ Create a sorted array `b`, numbers first. Iterate over the arguments. If `i` is a letter (>ascii #64) then decrement `k` and print `b[k]`, (e.g. `b[-2]` is the 2nd to last value). If `i` is a number, increment `j` and print `b[j]`. NB: Previously I forgot to decrease* letters. Fixed now, and saved bytes! ]
[Question] [ Given a list of strictly positive integers, go through each distinct number and replace all occurrences of it with successive indices (zero or one based) of a new series. ## Examples `[]` → `[]`/`[]` `[42]` → `[0]`/`[1]` `[7,7,7]` → `[0,1,2]`/`[1,2,3]` `[10,20,30]` → `[0,0,0]`/`[1,1,1]` `[5,12,10,12,12,10]` → `[0,0,0,1,2,1]`/`[1,1,1,2,3,2]` `[2,7,1,8,2,8,1,8,2,8]` → `[0,0,0,0,1,1,1,2,2,3]`/`[1,1,1,1,2,2,2,3,3,4]` `[3,1,4,1,5,9,2,6,5,3,5,9]` → `[0,0,0,1,0,0,0,0,1,1,2,1]`/`[1,1,1,2,1,1,1,1,2,2,3,2]` [Answer] # JavaScript (ES6), 26 bytes 1-indexed. ``` a=>a.map(o=x=>o[x]=-~o[x]) ``` [Try it online!](https://tio.run/##dc7NDoIwDADgu0/BEZIC@wHFw3gRwmFBMBpkRIzh5KvPFoMSB2u2Llm/dlf91EN1v/SPsDOn2jbKapXr6KZ736hR5aYYSxW@KAW2Mt1g2jpqzdlv/KIMAm9jxbFXlLu/@kRsCqrnDjgAxrqZAAiQDuIMBAPJVtwHYTgoBS4AJZ10WeAvomkgHCrwkxwyfM3mPOsfJSymBhISp4XE9wR3Ckes2WOWdKc2y@nLVvQT@wY "JavaScript (Node.js) – Try It Online") ### Commented ``` a => // a[] = input array a.map(o = // assign the callback function of map() to the variable o, so that // we have an object that can be used to store the counters x => // for each value x in a[]: o[x] = -~o[x] // increment o[x] and yield the result // the '-~' syntax allows to go from undefined to 1 ) // end of map() ``` [Answer] # [R](https://www.r-project.org/), 27 bytes ``` function(x)ave(x,x,FUN=seq) ``` [Try it online!](https://tio.run/##NYvNCgIxDITvPoXHBEZo011/QK8evfkAUlrYgxV3Xenb1xQiYTJfJsnc8va8a3kt8TO9ClV@fBNVVFzvt8uS3twylfWZ5imSY95kijSIwQFaxt5BHML/ZoQXaNZ7B4tFPzyOEJW5bYLOg2rESdO9eujM3H4 "R – Try It Online") Explanation : `ave(x,x,FUN=seq)` splits vector `x` into sub-vectors using values of `x` as grouping keys. Then `seq` function is called for each group and each result is re-arranged back in the original group position. Better see an example : ``` x <- c(5,7,5,5,7,6) ave(x, x, FUN=seq) # returns 1,1,2,3,2 ┌───┬───┬───┬───┬───┐ │ 5 │ 7 │ 5 │ 5 │ 7 │ └───┴───┴───┴───┴───┘ \| \| \| \| \| ▼ \| ▼ ▼ \| GROUP A : seq(c(5,5,5)) = c(1,2,3) \| \| \| \| \| ▼ \| ▼ ▼ \| ┌───┐ \| ┌───┬───┐ \| │ 1 │ \| │ 2 │ 3 │ \| └───┘ \| └───┴───┘ \| ▼ ▼ GROUP B : seq(c(7,7)) = c(1,2) \| \| ▼ ▼ ┌───┐ ┌───┐ │ 1 │ │ 2 │ └───┘ └───┘ \| \| \| \| \| ▼ ▼ ▼ ▼ ▼ ┌───┬───┬───┬───┬───┐ │ 1 │ 1 │ 2 │ 3 │ 2 │ └───┴───┴───┴───┴───┘ ``` Note : `seq(y)` function returns a sequence `1:length(y)` in case `y` has `length(y) > 1`, but returns a sequence from `1:y[1]` if `y` contains only one element. This is fortunately not a problem because in that case R - complaining with a lot of warnings - selects only the first value which is incidentally what we want :) [Answer] # [MATL](https://esolangs.org/wiki/MATL), 4 bytes ``` &=Rs ``` This solution is 1-based Try it out at [MATL Online](https://matl.io/?code=%26%3DRs&inputs=%5B5%2C12%2C10%2C12%2C12%2C10%5D&version=20.10.0)! Explanation Uses `[1,2,3,2]` as an example ``` # Implicitly grab the input array of length N # # [1,2,3,2] # &= # Create an N x N boolean matrix by performing an element-wise comparison # between the original array and its transpose: # # 1 2 3 2 # ------- # 1 \| 1 0 0 0 # 2 \| 0 1 0 1 # 3 \| 0 0 1 0 # 2 \| 0 1 0 1 # R # Take the upper-triangular portion of this matrix (sets below-diagonal to 0) # # [1 0 0 0 # 0 1 0 1 # 0 0 1 0 # 0 0 0 1] # s # Compute the sum down the columns # # [1,1,1,2] # # Implicitly display the result ``` [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 7 bytes Many, many thanks to H.PWiz, Adám and dzaima for all their help in debugging and correcting this. ``` +/¨⊢=,\ ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///X1v/0IpHXYtsdWL@pz1qm/Cob6pXsL/fo44ZGo96@4A8T/9HXc2H1hs/apsI5AUHOQPJEA/PYE2gEqji/2kK6tGx6lwgysQIyjDXAUIo29BAx8hAx9gAyjXVMTTSAYqBSBADKmwE1GGoY6FjBMRQGipjDOSbALGpjiVQ1AxIG4PYseoA "APL (Dyalog Unicode) – Try It Online") Explanation The 10-byte non-tacit version will be easier to explain first ``` {+/¨⍵=,\⍵} { } A user-defined function, a dfn ,\⍵ The list of prefixes of our input list ⍵ (⍵ more generally means the right argument of a dfn) \ is 'scan' which both gives us our prefixes and applies ,/ over each prefix, which keeps each prefix as-is ⍵= Checks each element of ⍵ against its corresponding prefix This checks each prefix for occurrences of the last element of that prefix This gives us several lists of 0s and 1s +/¨ This sums over each list of 0s and 1s to give us the enumeration we are looking for ``` The tacit version does three things * First, it removes the instance of `⍵` used in `,\⍵` as `,\` on the right by itself can implicitly figure out that it's supposed to operate on the right argument. * Second, for `⍵=`, we replace the `⍵` with `⊢`, which stands for right argument * Third, now that we have no explicit arguments (in this case, `⍵`), we can remove the braces `{}` as tacit functions do not use them [Answer] # [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 14 * 1 byte saved thanks to @NahuelFouilleul ``` {print++a[$1]} ``` [Try it online!](https://tio.run/##SyzP/v@/uqAoM69EWzsxWsUwtvb/f2MuQy4TIDblsuQy4jID0sYgNgA) The above does one-based indexing. If you prefer zero-based indexing, its an extra byte: ``` {print a[$1]++} ``` [Try it online!](https://tio.run/##SyzP/v@/uqAoM69EITFaxTBWW7v2/39jLkMuEyA25bLkMuIyA9LGIDYA "AWK – Try It Online") [Answer] # [J](http://jsoftware.com/), 7 bytes ``` 1#.]=]\ ``` [Try it online!](https://tio.run/##PYu7CoAwDEX3fsVFBRGkpK1v6J/oJBZxcXD222syREp6T06SK6cnWhAWUHal3eK25sYUFnWKtkaLd0F6jDn280YCVaTYeaVRnjaO4AnhX@vhvEj5BdR7PnKYOCdNHQUWHVePmfXAGYTzBw "J – Try It Online") 1-indexed. ## Explanation: ``` ]\ all the prefixes (filled with zeros, but there won't be any 0s in the input): ]\ 5 12 10 12 12 10 5 0 0 0 0 0 5 12 0 0 0 0 5 12 10 0 0 0 5 12 10 12 0 0 5 12 10 12 12 0 5 12 10 12 12 10 ]= is each number from the input equal to the prefix: (]=]\) 5 12 10 12 12 10 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 1 1 0 0 0 1 0 0 1 1#. sum each row: (1#.]=]\) 5 12 10 12 12 10 1 1 1 2 3 2 ``` # [K (oK)](https://github.com/JohnEarnest/ok), ~~11~~ 10 bytes -1 byte thanks to ngn! ``` {+/'x=,\x} ``` [Try it online!](https://tio.run/##y9bNz/7/P82qWltfvcJWJ6ai9n@agpGCuYKhggWQtoDR/wE "K (oK) – Try It Online") [Answer] # [Python 2](https://docs.python.org/2/), 48 bytes ``` lambda a:[a[:i].count(v)for i,v in enumerate(a)] ``` [Try it online!](https://tio.run/##VU7bDoIwDH33K5b4Akmju4AiiV8y9zAVIokMQoDEr8dWwJQ0W7uey0776V9N0FN5vU1vX9@fXvjceptX7vBohtBHY1w2nahgFFUQRRjqovN9EfnYTW1XhV6UkXWx2Avrjtbtdv9loue1xL3iwBmwFgwUaMJBg@EcJUFLMHKlYf1oWJyWgtKAXLppYHRyRvIiIn/8iUk1plCQIZCtnaslrDpKtrrMb/IykHA3g1CCJ4ULwifshuZtHu68zcbdKef0BQ "Python 2 – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes ``` ηε¤¢ ``` [Try it online!](https://tio.run/##yy9OTMpM/f//3PZzWw8tObTo//9oYx1DHRMgNtWx1DHSMQPSxiB2LAA "05AB1E – Try It Online") or as a [Test Suite](https://tio.run/##yy9OTMpM/W/u9v/c9nNbDy05tOh/rc7/6FiuaBMjIGGuA4RA2tBAx8hAx9gAyDTVMTTSAfJBJIgBFDICqjLUsdAxAmIoDRQ1BrJNgNhUxxIoYgakjUHsWAA) Explanation ``` ηε # apply to each prefix of the input list ¤¢ # count occurrences of the last element ``` [Answer] # BQN, 1 byte ``` ⊒ ``` [Try it here!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oqSCgpGIDPigL8x4oC/NOKAvzHigL814oC/OeKAvzLigL824oC/NeKAvzPigL814oC/OQ==), [All tests](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oqSCgooRiDigKJKcynCqOKfqAoKCiJbXSIKCiJbNDJdIgoKIls3LDcsN10iCgoiWzEwLDIwLDMwXSIKCiJbNSwxMiwxMCwxMiwxMiwxMF0iCgoiWzIsNywxLDgsMiw4LDEsOCwyLDhdIgoKIlszLDEsNCwxLDUsOSwyLDYsNSwzLDUsOV0iCuKfqQ==) I don't know much about BQN, but I learned from [this answer](https://codegolf.stackexchange.com/a/240424/3852) that this is a built-in. [Answer] # [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 44 bytes ``` x=>x.Select((y,i)=>x.Take(i).Count(z=>z==y)) ``` [Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpds4@maV5qbWpSYlJNqk5lXYqeDLmCnkKZg@7/C1q5CLzg1JzW5REOjUidTE8QPScxO1cjU1HPOL80r0aiytauyta3U1PxvzRVQBNSqkaaRl1oeHVttrgOEtZqa6OKmOoZGOoYGYBLEACn5DwA "C# (Visual C# Interactive Compiler) – Try It Online") [Answer] # Ruby, 35 bytes ``` ->a{f=Hash.new 0;a.map{\|v\|f[v]+=1}} ``` It's pretty mundane, unfortunately - build a hash that stores the total for each entry encountered so far. Some other, fun options that unfortunately weren't quite short enough: ``` ->a{a.dup.map{a.count a.pop}.reverse} # 37 ->a{i=-1;a.map{\|v\|a[0..i+=1].count v}} # 38 ``` [Answer] # [Python 2](https://docs.python.org/2/), ~~47~~ 43 bytes ``` f=lambda a:a and f(a[:-1])+[a.count(a[-1])] ``` [Try it online!](https://tio.run/##VU5dC8IwDHz3VxR8cRi1H5vOgb@k9KE6hoJ2Q@aDv75e3KYdIU1yuVyve/fXNugYm9PdP861F75Chlo0K2@rjXLZ2vrtpX2FHgDPLnbPW@hBsC4TS2HdzrrFD8v1gErAKsEPhBhXpEjzmjSZhKIkaUlGTizEl4VIWAUpTaDyy03CZl1wxxtWxz//Sw0Likrg5VTTY0nTGduaRIaZpQzliZjBJkcWdMR2j2q4n7tJhefOUnF2GT8 "Python 2 – Try It Online") A recursive 'one-based' solution. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes ``` ċṪ$Ƥ ``` [Try it online!](https://tio.run/##y0rNyan8//9I98Odq1SOLfn//3@0qY6hkY6hAZgEMWIB "Jelly – Try It Online") For each prefix of the input list, it counts the number of occurrences of its last element in itself. [Answer] # [R](https://www.r-project.org/), 41 bytes ``` function(x)diag(diffinv(outer(x,x,"=="))) ``` [Try it online!](https://tio.run/##NY7dCsMwCIXv9xSjVwoOEtPuB9qHGWkduVgKoRl5@8xAiuj5PCqYqlznW5Uc/RH2CAXX8P7AGkRC/MGejy1BoULDsgyIWAVi/m4peDCIFwEPI3d4kEZna4gNuXNnIsukXqsNus16YelJrNm1T5z2o@ZEL3Xvqq6xPvAH "R – Try It Online") Oddly, returning a zero-based index is shorter in R. [Answer] # [R](https://www.r-project.org/), ~~62~~ 43 bytes ``` x=z=scan();for(i in x)z[y]=1:sum(y<-x==i);z ``` -19 bytes thanks to Giuseppe, by removing which, and table, and only slight changes to the implementation Original ``` x=z=scan();for(i in names(r<-table(x)))z[which(x==i)]=1:r[i];z ``` I can't compete with Giuseppe's knowledge, so my submission is somewhat longer than his, but using my basic knowledge, I felt that this solution was rather ingenious. `r<-table(x)` counts the number of times each number appears and stores it in r, for future reference `names()` gets the values of each unique entry in the table, and we iterate over these names with a for loop. The remaining portion checks which entries are equal to the iterations and stores a sequence of values (from 1 to the number of entries of the iteration) [Try it online!](https://tio.run/##K/r/v8K2yrY4OTFPQ9M6Lb9II1MhM08hLzE3tVijyEa3JDEpJ1WjQlNTsyq6PCMzOUOjwtY2UzPW1tCqKDoz1rrqvymXoRGXoQGYBDH@AwA "R – Try It Online") [Answer] # [Haskell](https://www.haskell.org/), 44 bytes ``` ([]#) x#(y:z)=sum[1\|a<-x,a==y]:(y:x)#z _#e=e ``` [Try it online!](https://tio.run/##XU/NToNAEL7zFBPwAOlW@Wm1Nt2TV28e140hdPoTKWB3m1LSsw/gI/og4ixdGpQFZub7G9ik6h3zvF3x19YX0guc2vNP8ybg6rAT0TldjGuWcn6Sc4LrwGucNw85trt0WwCHZekAKPw4YJEhYJ3uqhwVYf7355eQAdzCHtMl8MUC1qifykJjoZXj1ApIAY2ikOqgX/T@uYAbUJvyCMSNRuB2Ate0HXrqUKwrzDQuacVxg3ukCobisCJfNw0k5job@o6bVaRyX7XfC@aD9OayM3CvrlJT/nGr0Lhcx@l/DjhJBAjZfZ@QNDEQk9jOoQUeGJ0eYxGLLR6FLA5ZEl4pOpaasihmxJu3aYYSk8AiK4wpO2IzQmZ9/aM16qhzxCyxnoTmCT1T9kjoPdXE9P92DP12n2xFl3a52bWXP9kqT9eqHWdV9Qs "Haskell – Try It Online") ## Explanation Traverses the list from left to right keeping the list `x` of visited elements, initially `[]`: For every encounter of a `y` count all equal elements in the list `x`. [Answer] # [Perl 6](https://github.com/nxadm/rakudo-pkg), 15 bytes ``` >>.&{%.{$_}++} ``` [Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwX8vOTk@tWlWvWiW@Vlu79r81V3FipUKaRnSsJpxpYoTEMdcBQiS@oYGOkYGOsQGSkKmOoZEOUBxEghhIUkZA3YY6FjpGQAylkWSNgWImQGyqYwmUMQPSxiA2UMV/AA "Perl 6 – Try It Online") You can move the `++` to before the `%` for a one based index. ### Explanation: ``` >>.&{ } # Map the input to % # An anonymous hash .{$_} # The current element indexed ++ # Incremented ``` [Answer] # [Haskell](https://www.haskell.org/), ~~47~~ 46 bytes ``` (#(0)) (x:r)#g=g x:r# \y->0^(y-x)^2+g y e#g=e ``` [Try it online!](https://tio.run/##XU/NToNAEL7vU0yoB7BbhaXV2nS9ePXmkdKE0CltpIDsNoXGsw/gI/og4ixCg7JhZ@b7mQ92kXrFNG22ctXYI/vadRxmV4vSGSUyAWpGsKonj@7aria1sxbjBGqGRGJziPYZSNjkDEDh2xGzGAGr6FCkqAizvz4@g9CBGygx2oBcLiFB/ZRnGjOtGKsUkALOipYUR/2iy@cMrkDt8hMQNx6D1Qos07Zo3aJYFRhr3FDEaYclUgVDSdiSr50GEvO8G/pWmihSWStt94LFYPv5N9OxLq5c0/7TXqFxWYz1PweSJAEEYft9QUgTh2AqutntgHtOp8e4x0WHey4XLvfdC0Wno2bcE5x4c5tmKDEbuNcJBe32@JyQeV//aI3aax2C@53Hp3lK74w/EHpH1Tf9v4yhv8sLmyD8jrdplKhmEhfFDw "Haskell – Try It Online") A different approach than [BMO's answer](https://codegolf.stackexchange.com/a/178549/56433) which turned out a bit longer. (And kindly borrows their nice test suit.) The idea is to iterate over the input list and keep track of the number of times each element has occurred by updating a function `g`. Ungolfed: ``` f (const 0) f g (x:r) = g x : f (\ y -> if x==y then 1 + g y else g y) r f g [] = [] ``` Two interesting golfing opportunities arose. First for the initial value of `g`, a constant function which disregards its argument and returns `0`: ``` const 0 -- the idiomatic way (\_->0) -- can be shorter if parenthesis are not needed min 0 -- only works as inputs are guaranteed to be non-negative (0) -- obvious in hindsight but took me a while to think of ``` And secondly an expression over variables `x` and `y` which yields `1` if `x` equals `y` and `0` otherwise: ``` if x==y then 1else 0 -- yes you don't need a space after the 1 fromEnum$x==y -- works because Bool is an instance of Enum sum[1\|x==y] -- uses that the sum of an empty list is zero 0^abs(x-y) -- uses that 0^0=1 and 0^x=0 for any positive x 0^(x-y)^2 -- Thanks to Christian Sievers! ``` There still might be shorter ways. Anyone got an idea? [Answer] # [Java (JDK)](http://jdk.java.net/), 76 bytes ``` a->{for(int l=a.length,i,c;l-->0;a[l]=c)for(c=i=0;i<l;)c+=a[l]==a[i++]?1:0;} ``` [Try it online!](https://tio.run/##hVFdT4MwFH3fr7ghMQFXCB9T5zowxmeffCQ81A5mZymkLTPLwm/HUpySGGPS3p6ec3pvb3sgR@Ifdu8Dq9tGajiYfdBpxoNrvPjFVZ2gmjViFCknSsEzYQLOC4C2e@WMgtJEm@XYsB3URnNftGRinxdA5F551grw1AjV1aXcMqHzIoMK0oH42blqpGso4CkJeCn2@g0xRDH3/SzEJOdFSr3RQ1OWhphtOfboMrWCiWy5LB6iTYj7AdsyRyJBl0orSEGUH2Cr5cV0B4Az9OgbruL57g7ZMaeiEEFsZhLO2RsEUYysaFeL54bYZooQrNGI13M89yVWWNlokt5bx63FycRc3P3UnA3jY1y63Ey9Xt4Y4OWkdFkHTaeD1nyCrlznyk9CBX4GDoJHKclJBbqZvsgdT3uBLFtOaOk6xuI4noe/klUBobRs9WTDf5Tgwv0/Lfzk7Rfj7IdP "Java (JDK) – Try It Online") ## Credits * -2 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) [Answer] # [Tcl](http://tcl.tk/), 48 bytes ``` proc C L {lmap n $L {dict g [dict inc D $n] $n}} ``` [Try it online!](https://tio.run/##LY7NCsIwEITveYo59AGSTevPuR59g7YHiSCFGoPGU9hnj5Miy@x8OwwkOWy1pvcrYMQVZXveEiI64n0NGQ9Mu68x4IIuLpRq3WvsmKKm9MJ1BIfuLMTCW@IAJ@DddgNGwpbDCUL9nakn99SAM5MD3TdWGEVJ3/zBXKaRn1pmvv0D "Tcl – Try It Online") [Answer] # [Ruby](https://www.ruby-lang.org/), 34 bytes ``` ->a{r=[];a.map{\|x\|(r<<x).count x}} ``` [Try it online!](https://tio.run/##KypNqvyfZvtf1y6xusg2OtY6US83saC6pqJGo8jGpkJTLzm/NK9EoaK29n@BQlp0dGwsF5g2MYKxzHWAEMYxNNAxMtAxNoDxTXUMjXSAgiASxICJGwE1GepY6BgBMZSGSRkDBUyA2FTHEihsBqSNQezY2P8A "Ruby – Try It Online") [Answer] # bash, ~~37~~ 24 bytes ``` f()(for x;{ r+=$[a[x]++]\ ;};echo $r) ``` [TIO](https://tio.run/##NYo7CoAwEER7TzGFhZImH78ET6IWKgY7ITaCePY4W8iy894Ouy7XkVIoyiKcEbd/ENWQj8t4z0rNE/zr9@04kccyhSygsoxWhjQaVsNpag1j5ZYUYWX5ZdCR3U@2jl5xa/RsGtKJpw8) if valid, there is also this variation, as suggested by DigitalTrauma ``` for x;{ echo $[a[x]++];} ``` [TIO](https://tio.run/##S0oszvj/Py2/SKHCuporNTkjX0ElOjG6IlZbO5ar9v///8b/Df@bALHpf8v/Rv/NgLQxiA0A) [Answer] # Perl 5, 11 bytes ``` $_=$h{$_}++ ``` [TIO](https://tio.run/##K0gtyjH9/18l3lYlo1olvlZb@/9/Yy5DLhMgNuWy5DLiMgPSxiD2v/yCksz8vOL/ugU5AA) explanations following comment * `$_` perl's special variable containing current line when looping over input (`-p` or `-n` switches) * `$h{$_}++` autovivifies the map `%h` and creates an entry with key `$_` and increments and gives the value before increment * the special variable is printed because of `-p` switch, `-l` switch removes end of line on input and adds end of line on output [Answer] # [Pari/GP](http://pari.math.u-bordeaux.fr/), 32 bytes ``` a->p=0;[polcoeff(p+=x^t,t)\|t<-a] ``` The \$k\$-th element in the answer is the coefficient of the \$x^{a\_k}\$ term in the polynomial \$\sum\_{i=1}^kx^{a\_i}\$. [Try it online!](https://tio.run/##LYrbCsIwEER/JfQpwQ3k0npB0x8pERYxUijtUvKg4L/HXZBlZs4MS7jP9kWtqNTQjpTcdaJteWzPUjQd0vteoZpvvVnMDYmWj0ZlR0X7vFbGTkqnikZjQE1TZuuD@An4BLyD4CA64QF8AB7EBWQL/OjhDIH1T5kjl541wIWnI2cUztm0Hw "Pari/GP – Try It Online") [Answer] # [Attache](https://github.com/ConorOBrien-Foxx/Attache), 23 bytes ``` {`~&>Zip[_,_[0:#_::0]]} ``` [Try it online!](https://tio.run/##NYs7C0IxDIX3/oqC4pShj3t9FHRxFwcnS6jl2qt3kWK7if71mqJNSM45X4jP2Q/3UEZutry8Lp/F7jxF68BZYWbOGIH4LocQrsnOYxxuyI7P6ZFPIeW9TyHZEbhlnMoi/LRTza2AugUpQAnQouUepAKCdVfTuKInCWtQNH9tJ02go@lhQ3hJqqtHhli@ "Attache – Try It Online") ## Explanation ``` {`~&>Zip[_,_[0:#_::0]]} { } _: input (e.g., [5, 12, 10, 12, 12, 10]) 0:#_ range from 0 to length of input (inclusive) e.g., [0, 1, 2, 3, 4, 5, 6] ::0 descending range down to 0 for each element e.g., [[0], [1, 0], [2, 1, 0], [3, 2, 1, 0], [4, 3, 2, 1, 0], [5, 4, 3, 2, 1, 0], [6, 5, 4, 3, 2, 1, 0]] _[ ] get input elements at those indices e.g., [[5], [12, 5], [10, 12, 5], [12, 10, 12, 5], [12, 12, 10, 12, 5], [10, 12, 12, 10, 12, 5], [nil, 10, 12, 12, 10, 12, 5]] Zip[_, ] concatenate each value with this array e.g., [[5, [5]], [12, [12, 5]], [10, [10, 12, 5]], [12, [12, 10, 12, 5]], [12, [12, 12, 10, 12, 5]], [10, [10, 12, 12, 10, 12, 5]]] &> using each sub-array spread as arguments... `~ count frequency e.g. [12, [12, 10, 12, 5]] = 12 ~ [12, 10, 12, 5] = 2 ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~65~~ 62 bytes ``` c,d;f(a,b)inta;{for(;c=d=b--;a[b]=d)for(;c--;d-=a[c]!=a[b]);} ``` [Try it online!](https://tio.run/##JUtLCsIwEN33FLUgZGwCrWA345wkZDGdUJmFVYq7kLPHRDfv/8Q9RMqTdTeQOt0/PftA6Wbnq52nHzaRsdsM2wUqvw7TdkoT6n1BHUd4HzXZzHCO/WDZa6i7XMRGbK8VanthTO2KQpFW55D9GijCP6s@OmIv4UStAMylfAE "C (gcc) – Try It Online") -2 bytes thanks to [ASCII-only](https://codegolf.stackexchange.com/questions/178500/enumerate-each-series-of-identical-numbers-in-place/178724?noredirect=1#comment430784_178724) --- This felt too straightforward, but I couldn't seem to get any shorter with a different approach. [Answer] # [K (ngn/k)](https://gitlab.com/n9n/k), 18 bytes ``` (,/.!'#'=x)@<,/.=x ``` [Try it online!](https://tio.run/##y9bNS8/7X2FlrGCoYALEpgqWCkYKZkDaGMT@r6Gjr6eorqxuW6HpYANk21b8/w8A "K (ngn/k) – Try It Online") --- OLD APPROACH* # [K (ngn/k)](https://gitlab.com/n9n/k), ~~27 23~~ 22 bytes ``` {x[,/.=x]:,/.!'#'=x;x} ``` [Try it online!](https://tio.run/##y9bNS8/7/z/NqroiWkdfz7Yi1gpIKaorq9tWWFfU/k9TMFYwVDABYlMFSwUjBTMgbQxi/wcA "K (ngn/k) – Try It Online") --- this is not pretty... quick and dirty solution, i will be refining this later when i get the chance to think of a better approach explanation: * `=x` returns a dict where keys are items of x and values are their indices (`3 1 4 5 9 2 6!(0 9;1 3;,2;4 8 10;5 11;,6;,7)`) * `i:` assign dict to `i` * `#:'` count values for each key (`3 1 4 5 9 2 6!2 2 1 3 2 1 1`) * `!:'` enumerate each value (`3 1 4 5 9 2 6!(0 1;0 1;,0;0 1 2;0 1;,0;,0)`) * `,/.:` extract values and flatten list (`0 1 0 1 0 0 1 2 0 1 0 0`) * `x[,/.:i]:` extract indices from i, flatten, and assign each value from the right-side list at these indices annoyingly, the list is updated but a null value is returned by the assignment, so i need to return the list after the semicolon (`;x`) edit: removed extraneous colons edit2: removed unnecessary assignment [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 4 bytes ``` KƛtO ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJLxpt0TyIsIiIsIls1LDEyLDEwLDEyLDEyLDEwXSJd) `KƛṫO` is also valid for 4 bytes Simply count the number of occurrences of the tail of each prefix in each prefix. [Answer] # [Factor](https://factorcode.org/), 48 bytes ``` [ dup [ head [ = ] with count ] with map-index ] ``` [Try it online!](https://tio.run/##PY5BDoJADEX3c4p/AQ0MoKhxbdy4Ma4ICwI1EHUYhyFqCGcfCwHatO/3N016z3JbG3e7ni@nPR5kFD3R0LsllVMDbcjanzaVsjgI0QlwdOgnhnKR2zHnyfcgPQTeYkTw5eAOfRTzQvKVj5gZL5x3ATshV4Qd@xtmMOpe9C5B0WokKCkrGEek@FS2RF63/Os0vDK9qlRBX6SONdbuDw "Factor – Try It Online") [Answer] # [Husk](https://github.com/barbuz/Husk), 4 bytes ``` z#ḣ¹ ``` [Try it online!](https://tio.run/##yygtzv7/v0r54Y7Fh3b@//8/2lTH0EjH0ABMghixAA "Husk – Try It Online") ### Explanation one-indexed ``` z#ḣ¹ transforms to z#ḣ⁰⁰ z zip ḣ⁰ prefixes of input ⁰ and input # with count ``` ]
[Question] [ We are all familiar with the [Fibonacci sequence](https://oeis.org/A000045): ``` 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765 ``` However, instead of, `f(n) = f(n-1) + f(n-2)` we'll be taking [digital sum](https://en.wikipedia.org/wiki/Digit_sum) of the previous 2 entries. --- The sequence should still start with `0, 1`, after that the differences are rapidly apparent. This list is 0-indexed, you may use 1-indexed as well, state which you used. ``` f(0) = 0 f(1) = 1 f(2) = 1 # 0 + 1 f(3) = 2 # 1 + 1 f(4) = 3 # 1 + 2 f(5) = 5 # 2 + 3 f(6) = 8 # 3 + 5 f(7) = 13 # 8 + 5 f(8) = 12 # 8 + 1 + 3 f(9) = 7 # 1 + 3 + 1 + 2 f(10) = 10 # 1 + 2 + 7 f(11) = 8 # 7 + 1 + 0 f(12) = 9 # 1 + 0 + 8 f(13) = 17 # 8 + 9 f(14) = 17 # 9 + 1 + 7 f(15) = 16 # 1 + 7 + 1 + 7 f(16) = 15 # 1 + 7 + 1 + 6 f(17) = 13 # 1 + 6 + 1 + 5 f(18) = 10 # 1 + 5 + 1 + 3 f(19) = 5 # 1 + 3 + 1 + 0 f(20) = 6 # 1 + 0 + 5 f(21) = 11 # 5 + 6 f(22) = 8 # 6 + 1 + 1 f(23) = 10 # 1 + 1 + 8 f(24) = 9 # 8 + 1 + 0 f(25) = 10 # 1 + 0 + 9 f(26) = 10 # 9 + 1 + 0 f(27) = 2 # 1 + 0 + 1 + 0 (After this point it repeats at the 3rd term, 0-indexed) ``` Note: I didn't notice the repetition until I posted the challenge itself, and here I was thinking it'd be impossible to write another novel Fibonacci challenge. --- Your task is, given a number `n`, output the nth digit of this sequence. First 3 digits: `[0,1,1]`, 24-digit repeated pattern: `[2,3,5,8,13,12,7,10,8,9,17,17,16,15,13,10,5,6,11,8,10,9,10,10]` Hint: You may be able to exploit this repetition to your advantage. --- This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), lowest byte-count is the winner. --- BONUS: If you use the repetition in your answer, I will award the lowest byte-count answer that takes advantage of the repetition in the sequence a bounty of 100 points. This should be submitted as part of your original answer, after your original answer. See this post as an example of what I am talking about: <https://codegolf.stackexchange.com/a/108972/59376> To qualify for this bonus your code must run in constant time (`O(1)`) with an explanation. *Bonus Winner: Dennis <https://codegolf.stackexchange.com/a/108967/59376>* < Dennis won. *Most Unique Implementation: <https://codegolf.stackexchange.com/a/108970/59376> (Also will receive 100 points, finalized after correct answer is chosen)* [Answer] ## JavaScript (ES6), 45 bytes ``` f=(n,x=0,y=1)=>n?f(n-1,y,(x%9\|\|x)+(y%9\|\|y)):x ``` ``` <input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o> ``` `x` and `y` can't both be `9`, since that would require the previous number to be `0`, so their digital sum can't exceed `17`. This means that the digital root for numbers greater than `9` is the same as the remainder modulo `9`. [Answer] # Python 2, 53 bytes ``` f=lambda n:n>1and sum(map(int,`f(n-1)`+`f(n-2)`))or n ``` Recursive function. The base cases of `n=0` and `n=1` yield `n`, larger numbers calculate the value by calling `f(n-1)` and `f(n-2)` converting each to a string, concatenating the two strings, converting each character to an integer using a `map` with the `int` function, and then sums the resulting list. --- Using the modulo-24 information I can currently get a 56 byte non-recursive unnamed function: ``` lambda n:int(('011'+'2358dc7a89hhgfda56b8a9aa'n)[n],18) ``` [Answer] # JavaScript (ES6), 34 bytes ``` f=n=>n<2?n:~-f(--n)%9+~-f(--n)%9+2 ``` May freeze your browser for inputs above 27 or so, but it does work for all input values. This can be verified with a simple cache: ``` c=[];f=n=>n<2?n:c[n]=c[n]\|\|~-f(--n)%9+~-f(--n)%9+2 ``` ``` <input type=number value=0 min=0 step=1 oninput="O.value=f(this.value)"> <input id=O value=0 disabled> ``` As pointed out in [Neil's brilliant answer](https://codegolf.stackexchange.com/a/108970/42545), the output can never exceed 17, so the digital sum of any output above 9 is equal to `n%9`. This also works with outputs below 9; we can make it work for 9 as well by subtracting 1 with `~-` before the modulus, then adding back in 1 after. --- The best I could do with hardcoding is 50 bytes: ``` n=>"0x"+"7880136ba5867ffedb834968"[n%24]-(n<3)9+2 ``` [Answer] # [Oasis](https://github.com/Adriandmen/Oasis), 5 bytes Code: ``` ScS+T ``` [Try it online!](https://tio.run/nexus/oasis#@x@cHKwd8v//fyNDAA "Oasis – TIO Nexus") Expanded version: ``` ScS+10 ``` Explanation: ``` ScS+ = a(n) 0 = a(0) 1 = a(1) S # Sum of digits on a(n-1) c # Compute a(n-2) S # Sum of digits + # Add together ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes ``` ;DFS ç¡1 ``` [Try it online!](https://tio.run/nexus/jelly#@2/t4hbMdXj5oYWG//8bmgIA "Jelly – TIO Nexus") ### How it works ``` ç¡1 Main link. No arguments. Implicit left argument: 0 1 Set the right argument to 1. ç¡ Repeatedly execute the helper link n times – where n is an integer read from STDIN – updating the left argument with the return value and the right argument with the previous value of the left argument. Yield the last result. ;DFS Helper link. Arguments: a, b ; Concatenate; yield [a, b]. D Decimal; convert both a and b to their base-10 digit arrays. F Flatten the result. S Compute the sum of the digits. ``` ## Alternate solution, 19 bytes, constant time ``` ;DFS 9⁵ç23Ð¡⁸ịµṠ>?2 ``` [Try it online!](https://tio.run/nexus/jelly#ATAAz///O0RGUwo54oG1w6cyM8OQwqHigbjhu4vCteG5oD4/Mv8wcjI3wrXFvMOH4oKsR/8 "Jelly – TIO Nexus") ### How it works ``` 9⁵ç23Ð¡⁸ịµṠ>?2 Main link. Argument: n 9 Set the return value to 9 ⁵ Yield 10. ç23Ð¡ Execute the helper link 23 times, with initial left argument 10 and initial right argument 9, updating the arguments as before. Yield all intermediate results, returning [10,10,2,3,5,8,13,12,7,10,8,9,17,17,16,15,13,10,5,6,11,8,10,9]. ⁸ị Extract the element at index n. Indexing is 1-based and modular. µ Combine all links to the left into a chain. >?2 If n > 2, execute the chain. Ṡ Else, yield the sign if n. ``` [Answer] # JavaScript (ES6), ~~52 46~~ 45 bytes ``` _=$=>$<2?$:eval([..._(--$)+[_(--$)]].join`+`) ``` # Usage ``` _=$=>$<2?$:eval([..._(--$)+[_(--$)]].join`+`) _(7) ``` ## Output ``` 13 ``` # Explanation This function checks if the input is smaller than 2, and if so, it returns the input. Otherwise, it creates an array of two values that are appended to each other as strings. Those two values are the result of calling the function with `input - 1` and `input - 2`. The `...` operator splits this string into an array of characters, which then is converted to a string again, but now with `+`es between values. This string is then interpreted as code, so the sum is calculated, which is then returned. This is a double-recursive algorithm, which makes it quite inefficient. It needs 2`n-2` function calls for input `n`. As such, here's a longer but faster solution. Thanks to ETHproductions for coming up with it. ``` f=($,p=1,c=0)=>$?f($-1,c,eval([...p+[c]].join`+`)):c ``` [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes ``` XÎF‚¤sSO ``` [Try it online!](https://tio.run/nexus/05ab1e#@x9xuM/tUcOsQ0uKg/3//zcyBwA "05AB1E – TIO Nexus") Explanation ``` XÎ # push 1,0,input F # input_no times do: ‚ # pair the top 2 elements of the stack ¤ # push a copy of the 2nd element to the stack s # swap the pair to the top of the stack S # convert to list of digits O # sum ``` [Answer] # CJam, ~~22~~ 20 bytes Saved 2 bytes thanks to Martin Ender ``` ri2,{(_(jAb\jAb+:+}j ``` Straightforward recursive algorithm, nothing fancy. 0-indexed. [Try it online!](https://tio.run/nexus/cjam#@1@UaaRTrRGvkeWYFAPE2lbatVn//1sAAA) or [test for 0-50](https://tio.run/nexus/cjam#@29qUG2kU60Rr5HlmGSlHQMmtWuzalUL/v83BQA) (actually runs pretty fast). Explanation ``` ri Read an integer from input 2, Push the array [0 1] { }j Recursive block, let's call it j(n), using the input as n and [0 1] as base cases ( Decrement (n-1) _( Duplicate and decrement again (n-2) jAb Get the list digits of j(n-2) \ Swap the top two elements jAb Get the list of digits of j(n-1) + Concatenate the lists of digits :+ Sum the digits ``` # CJam, 42 bytes Solution using the repetition. Similar algorithm to Jonathan Allan's solution. ``` ri_2,1+"[2358DC7A89HHGFDA56B8A9AA]"S~@+= ``` [Try it online!](https://tio.run/nexus/cjam#@1@UGW@kY6itFG1kbGrh4mzuaGHp4eHu5uJoauZk4Wjp6BirFKxV56Clbfv/vxkA "CJam – TIO Nexus") [Answer] # [Perl 6](https://perl6.org), ~~41~~ 37 bytes ``` {(0,1,{[+] \|$^a.comb,\|$^b.comb}...)[$_]} ``` [Try it](https://tio.run/nexus/perl6#Ky1OVSgz00u25sqtVFBLzk9JVbBV@F@tYaBjqFMdrR2rUKMSl6iXnJ@bpANkJYFZtXp6elqa0SrxsbX/ixMrFVLyFdLyixTijCwUqrkUFMCGqMRz1f7/mpevm5yYnJEKAA "Perl 6 – TIO Nexus") ``` {(0,1,.comb.sum+.comb.sum...)[$_]} ``` [Try it](https://tio.run/nexus/perl6#Ky1OVSgz00u25sqtVFBLzk9JVbBV@F@tYaBjqKOll5yfm6RXXJqrjWDq6elpaUarxMfW/i9OrFRIyVdIyy9SiDOyUKjmUlAAG6ASz1X7/2tevm5yYnJGKgA "Perl 6 – TIO Nexus") ``` { # bare block lambda with implicit parameter ｢$_｣ ( 0, 1, # first two values # WhateverCode lambda with two parameters ( the two ｢｣ ) .comb.sum # digital sum of first parameter + .comb.sum # digital sum of second parameter ... # keep using that code object to generate new values until: # never stop )[ $_ ] # index into the sequence } ``` [Answer] # [MATL](https://github.com/lmendo/MATL), 15 bytes ``` lOi:"yyhFYAss]& ``` [Try it online!](https://tio.run/nexus/matl#@5/jn2mlVFmZ4RbpWFwcq/b/v5E5AA "MATL – TIO Nexus") ``` lO % Push 1, then 0. So the next generated terms will be 1, 1, 2,... i % Input n :" % Repeat that many times yy % Duplicate top two elements in the stack h % Concatenate into length-2 horizontal vector FYA % Convert to decimal digits. Gives a 2-row matrix ss % Sum of all matrix entries ] % End & % Specify that next function (display) will take only 1 input % Implicit display ``` [Answer] # [Python 2](https://docs.python.org/2/), ~~54~~ 46 bytes ``` f=lambda n:n>2and~-f(n-1)%9+~-f(n-2)%9+2or n>0 ``` Heavily inspired by [@ETHproductions' ES6 answer](https://codegolf.stackexchange.com/a/108977/12012). [Try it online!](https://tio.run/nexus/python2#@59mm5OYm5SSqJBnlWdnlJiXUqebppGna6ipaqkNYRqBmEb5RQp5dgb/00C0QmaeQlFiXnqqhpGFphUXZ0FRZl6JgrqqUYqCrp0CkFJXUFXQyNNRAGrX1PwPAA "Python 2 – TIO Nexus") [Answer] # C, 96 bytes or 61 bytes counting escape codes as 1 byte each 0 indexed. Similar to some of the other answers I am indexing a lookup table of values but I have compressed it into 4 byte chunks. I didn’t bother investigating the mod 24 version because I didn’t think it was as interesting since the others have done so already but let’s face it, C isn’t going to win anyway. ``` #define a(n) n<3?!!n:2+(15&"\x1\x36\xba\x58\x67\xff\xed\xb8\x34\x96\x87\x88"[(n-3)/2%12]>>n%24) ``` explanation: ``` #define a(n) // using a preprocessor macro is shorter than defining a function n<3?!!n: // when n is less than 3 !!n will give the series 0,1,1,1..., otherwise.. (n-3)/2%12 // condition the input to correctly index the string... "\x1\x36\xba\x58\x67\xff\xed\xb8\x34\x96\x87\x88" // which has the repeating part of the series encoded into 4 bits each number // these are encoded 2 less than what we want as all numbers in the series after the third are 2 <= a(n>2) <= 17 which conforms to 0 <= a(n>2) - 2 <= 15 >>n%24 // ensure the data is in the lower 4 bits by shifting it down, n%2 will give either 0 or 1, which is then multiplied by 4 15& // mask those bits off 2+ // finally, add 2 to correct the numbers pulled from the string ``` [Try it online!](https://tio.run/nexus/c-gcc#HY5BDoIwFET3nOKDwbQCkVLAKogH8bvAtE1Y8DUNJk2MZ8fqambeZJJZN9rYiQyMjDhQLy9xTKcqY6LZJugFetmiv4/oG4W@PaC3Fr3RgYUsa/TH0KvAlUqujArJ91UqqtswUFrtar5OtMA8TsQ4vCMAsA8H7A/hDGUXpAdR/kyWcXi6UFmWpBqKAVKNlOQw5@HezHn32zuzvByFZfRZvw) [Answer] # [Japt](https://github.com/ETHproductions/japt), 27 25 bytes ``` U<2?U:~-ß´U %9+~-ß´U %9+2 ``` [Try it online!](https://tio.run/nexus/japt#@x9qY2QfalWne3j@oS2hCqqW2khMo///DQE "Japt – TIO Nexus") Saved 2 bytes thanks to ETHproductions. [Answer] # [Haskell](https://www.haskell.org/), 54 bytes ``` a!b=sum$read.pure<$>([a,b]>>=show) g=0:scanl(!)1g (g!!) ``` [Try it online!](https://tio.run/nexus/haskell#@5@omGRbXJqrUpSamKJXUFqUaqNipxGdqJMUa2dnW5yRX67JlW5rYFWcnJiXo6GoaZj@PzcxM0/BVgGkwSdPAahKoaAoM69EQU9BI11RUfO/oREA "Haskell – TIO Nexus") Usage: `(g!!) 12` [Answer] ## Mathematica, 49 bytes ``` If[#<2,#,Tr[Join@@IntegerDigits[#0/@{#-1,#-2}]]]& ``` Straightforward recursive definition. Gets pretty slow after a while. ## Mathematica, ~~79~~ 71 bytes ``` If[#<3,Sign@#,(9@@LetterNumber@"JJBCEHMLGJHIQQPOMJEFKHJ")[[#~Mod~24]]]& ``` Hardcoding the periodic pattern. Lightning fast and satisfyingly abusive to Mathematica :) Thanks to JungHwan Min for saving 8 bytes! [Answer] # [Python 2](https://docs.python.org/2/), 56 bytes Simple iterative solution. ``` a,b=0,1 exec'a,b=b,(a%9or a)+(b%9or b);'input() print a ``` [Try it online!](https://tio.run/nexus/python2#@5@ok2RroGPIlVqRmqwO4iTpaCSqWuYXKSRqamskgVlJmtbqWpl5BaUlGppcBUWZeSUKif//GxkAAA "Python 2 – TIO Nexus") Using `(a%9or a)+(b%9or b)` actually turned out to be shorter than `sum(map(int(`a`+`b`)))`! [Answer] # [PowerShell](https://github.com/PowerShell/PowerShell), 79 bytes ``` $b,$c=0,1;for($a=$args[0];$a;$a--){$z=[char[]]"$b$c"-join'+'\|iex;$b=$c;$c=$z}$b ``` [Try it online!](https://tio.run/nexus/powershell#DcxLCoAgFAXQvcgFixSsUSBvJeJApY8NEmwSVms34YxPhRcIpMSo15Q7OILL22WU1XCNlP2DQibsLhtrGTwCk0eKJx/4G5dbwxOCbgfKB19rneYf "PowerShell – TIO Nexus") Lengthy boring iterative solution that does direct digit-sum calculations each `for` loop. At the end of the loop, the number we want is in `$b`, so that's left on the pipeline and output is implicit. Note that if the input is `0`, then the loop won't enter since the conditional is false, so `$b` remains `0`. [Answer] ## Batch, 85 bytes ``` @set/ax=0,y=1 @for /l %%i in (1,1,%1)do @set/az=x-x/109+y-y/109,x=y,y=z @echo %x% ``` I was wondering how I was going to port my JavaScript answer to batch but the clue was in @Dennis's Python solution. [Answer] # Pyth, 20 bytes ``` J,01VQ=+JssjRT>2J)@J ``` A program that takes input of a zero-indexed integer and prints the result. [Test suite](http://pyth.herokuapp.com/?code=pQp%22+-%3E+%22+J%2C01VQ%3D%2BJssjRT%3E2J%29%40J&test_suite=1&test_suite_input=0%0A1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A9%0A10%0A11%0A12%0A13%0A14%0A15%0A16%0A17%0A18%0A19%0A20%0A21%0A22%0A23%0A24%0A25%0A26%0A27&debug=0) (First part for formatting) How it works* [Explanation coming later] [Answer] ## Ruby, 58 bytes ``` ->n{n<3?n<=>0:"9aa2358dc7a89hhgfda56b8a"[n%24].to_i(18)} ``` The simple hardcoded solution. [Answer] # [stacked](https://github.com/ConorOBrien-Foxx/stacked), 40 bytes ``` {!2:>[:$digitsflatmap sum\last\,]nlast} ``` This lambda is equivalent to the following lambda: ``` {n : 2:>[:$digitsflatmap sum\last\,]nlast} ``` [Try it online!](https://tio.run/nexus/stacked#@1@taGRlF22lkpKZnllSnJaTWJKbWKBQXJobk5NYXBKjE5unBWLU/newKkktLkkt4jJUMDJQqLFTUIHwFcDqM/LL/wMA "stacked – TIO Nexus") [Answer] # Octave, 148 bytes ``` function f = fib(n) if (n <= 1) f = n; else f = sum(int2str((fib(n - 1)))-48) + sum(int2str((fib(n - 2)))-48); endif endfunction ``` [Answer] ## Haskell, 151 bytes ``` import Numeric import Data.Char s i=foldr(\c i->i+digitToInt c)0$showInt i"" d a b=a:d b(s a+s b) f 0=0 f 1=1 f 2=1 f i=d 2 3!!fromIntegral(mod(i-3)24) ``` Invoke the function with `f 123456789012345678901234567890123456789012345678`, for example. The code works also with very big indices. Because of the implemented modulo 24 functionality it is very fast. The uncompressed code: ``` -- FibonacciDigital -- Gerhard -- 13 February 2017 module FibonacciDigital () where import Numeric import Data.Char -- sum of digits digitSum :: Int -> Int digitSum i = foldr (\c i -> i + digitToInt c) 0 $ showInt i "" -- fibonacci digital sequence function with arbitrary starting values fibonacciDigitals :: Int -> Int -> [Int] fibonacciDigitals a b = a : fibonacciDigitals b (digitSum a + digitSum b) -- index -> fibonacci digital value f :: Integer -> Int f 0 = 0 f 1 = 1 f 2 = 1 f i = fibonacciDigitals 2 3 !! fromIntegral (mod (i-3) 24) -- End ``` [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal) `2`, 7 bytes ``` ≬"Ṡ∑k≈Ḟ ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIyUCIsIiIsIuKJrFwi4bmg4oiRa+KJiOG4niIsIjMwMOG6jiIsIiJd) [Answer] # R, 90 bytes A horribly long solution, but it's better than the 108 I originally had. I suspect that there is a lot better way to do this, but I can't see it at the moment. ``` function(n,x=0:1){repeat`if`(n,{x=c(x,sum(scan(t=gsub('',' ',x))))[-1];n=n-1},break);x[1]} ``` This is an unnamed function that uses `gsub` and `scan(t=` to split the numbers in the vector into digits. The sum of these is added to the vector while the first item is dropped. `repeat` is used to step through the sequence `n` times and the result is the first item of the vector. [Answer] # PHP, 80 Bytes ``` for($r=[0,1];$i<$argn;)$r[]=array_sum(str_split($r[$i].$r[++$i]));echo$r[$argn]; ``` [Online Version](http://sandbox.onlinephpfunctions.com/code/1e93222a286864182c1c2eade6a1c2bb502b844b) [Answer] ## Mathematica, 67 bytes ``` r=IntegerDigits;f@0=0;f@1=1;f[x_]:=f@x=Tr@r@f[x-1]+Tr@r@f[x-2];f@#& ``` [Answer] # [Fig](https://github.com/Seggan/Fig), \$8\log\_{256}(96)\approx\$ 6.585 bytes ``` Gr2'+SxS ``` [Try it online!](https://fig.fly.dev/#WyJHcjInK1N4UyIsIiJd) Beats Jelly for once. ``` Gr2'+SxS G # Generate an infinite list using the initial terms... r2 # [0, 1] ' # And the generating function... Sx # Digit sum of first number S # Digit sum of second number + # Add the sums ``` [Answer] # [Japt](https://github.com/ETHproductions/japt), 11 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) ``` @Zo2 xì'x}g ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=QFpvMiB47Cd4fWc&input=OA) ]
[Question] [ Is [solving Sudoku](https://codegolf.stackexchange.com/questions/355/implement-a-non-guessing-sudoku-solver) too hard? Even the [brute force](https://codegolf.stackexchange.com/questions/378/implement-a-brute-force-sudoku-solver) version? Here's a coding exercise that's a little easier. I hope. :-P Write the shortest function to implement bogosort. In specific, your function should: * Take an array (or your language's equivalent) as input * Check if its elements are in sorted order; if so, return the array * If not, shuffle the elements, and start again The shortest entry wins. In the case of a tie, a function that supports a custom comparator (and/or pseudorandom number generator) is favoured. Any remaining ties are resolved by favouring the earlier submission. --- Clarifications: You can use any element type you want, as long as there's some way to order them, of course. Also, the shuffling has to be uniform; none of this "I'll just quicksort it and call it shuffled" business. :-) [Answer] ## Perl 6: 23 chars ``` @s.=pick()until[<=] @s ``` [Answer] ## APL(Dyalog), 20 ``` {⍵≡⍵[⍋⍵]:⍵⋄∇⍵[?⍨⍴⍵]} ``` Explanation* `⍵` is the (right) argument `⍵≡⍵[⍋⍵]`: Checks if `⍵` sorted equals `⍵` itself `:⍵`: If yes, then return `⍵` `∇⍵[?⍨⍴⍵]`: Else, generate an array of 1 to `⍴⍵` (length of `⍵`) in random order, reorder `⍵` according to that (`⍵[...]`), and apply the function to it (`∇`) --- Suddenly revisiting this problem and... ## APL(Dyalog), 19 ``` {∧/2≤/⍵:⍵⋄∇⍵[?⍨⍴⍵]} ``` Was just thinking about sorting an array in the check makes it kind of pointless (not saying that Bogosort is meaningful), a more accurate implementation would be `∧/2≤/⍵`, and that happens to lower the char count. [Answer] ### APL (22) ``` {(⍳X←⍴⍵)≡⍋⍵:⍵⋄∇⍵[X?X]} ``` Usage: ``` {(⍳X←⍴⍵)≡⍋⍵:⍵⋄∇⍵[X?X]} 3 2 1 1 2 3 ``` Explanation: * `⍋⍵`: returns the indexes of the items in sorted order, so `⍋30 10 20` gives `2 1 3` * `(⍳X←⍴⍵)≡⍋⍵:⍵` Store the length of input list in X. If range `[1..X]` is equal to the sorted index order, the list is sorted, so return it. * `⋄∇⍵[X?X]`: if this is not the case, recurse with shuffled array. [Answer] ## Ruby - 33 characters ``` g=->l{l.shuffle!!=l.sort ?redo:l} ``` [Answer] ### Mathematica, ~~40~~ 37 ``` NestWhile[RandomSample,#,Sort@#!=#&]& ``` With whitespace: ``` NestWhile[RandomSample, #, Sort@# != # &] & ``` [Answer] ## J - 34 27 ``` f=:({~?~@#)^:(1-(-:/:~))^:_ ``` eg: ``` f 5 4 1 3 2 1 2 3 4 5 f 'hello' ehllo ``` The {~ ?~@# part shuffles the input: ``` ({~ ?~@#) 1 9 8 4 4 8 9 1 ({~ ?~@#) 'abcd' bdca ``` [Answer] ## Python 61 Sorts in place. ``` import random def f(l): while l!=sorted(l):random.shuffle(l) ``` [Answer] # Python 94 ``` from itertools import* def f(a):return [x for x in permutations(a) if x==tuple(sorted(a))][0] ``` Other python answers use random.shuffle(). The documentation of the python random module states: > > Note that for even rather small len(x), the total number of > permutations of x is larger than the period of most random number > generators; this implies that most permutations of a long sequence can > never be generated. > > > [Answer] # K, 31 25 `{while[~x~x@<x;x:x@(-#x)?#x];x}` ``` {x@(-#x)?#x}/[{~x~x@<x};] ``` . ``` k){x@(-#x)?#x}/[{~x~x@<x};] 3 9 5 6 7 9 1 `s#1 3 5 6 7 9 9 ``` . ``` k){x@(-#x)?#x}/[{~x~x@<x};] "ascsasd" `s#"aacdsss" ``` [Answer] ## Python (69 chars) ``` from random import* def f(a): while a>sorted(a):shuffle(a) return a ``` Sorts integers in increasing numeric order. Note that recursive solutions, like `from random import;f=lambda a:a>sorted(a)and(shuffle(a)or f(a))or a` will fail due to stack overflow for even small inputs (say N>5), because Python does not do tail-call optimisation. [Answer] # D without custom comparator: 59 Characters ``` R f(R)(R r){while(!isSorted(r))r.randomShuffle();return r;} ``` More Legibly: ``` R f(R)(R r) { while(!r.isSorted) r.randomShuffle(); return r; } ``` # D with custom comparator: 69 Characters ``` R f(alias p,R)(R r){while(!isSorted!p(r))r.randomShuffle();return r;} ``` More Legibly: ``` R f(alias p, R)(R r) { while(!isSorted!p(r)) r.randomShuffle(); return r; } ``` [Answer] ### Scala 73: ``` def s(l:Seq[Int]):Seq[Int]=if(l==l.sorted)l else s(util.Random.shuffle l) ``` In Scala, we can check whether the compiler did a tail-call optimization: ``` @annotation.tailrec def s(l:Seq[Int]):Seq[Int]=if(l==l.sorted)l else s(util.Random shuffle l) ``` and yes, it did. However, for a short List of 100 values: ``` val rList = (1 to 100).map(x=>r.nextInt (500)) s(rList) ``` took nearly 4 months to complete. ;) [Answer] C# (184 chars)* ``` T[]S<T>(T[]i)where T:IComparable<T>{T l=default(T);while(!i.All(e=>{var r=e.CompareTo(l)>=0;l=e;return r;})){i=i.OrderBy(a=>Guid.NewGuid()).ToArray();l=default(T);}return i.ToArray();} ``` It's not really nice to do this in C#. You have to support generics to support both value and reference types. There is no array shuffle function or function to check if something is sorted. Does anybody got any tips to make this better? Edit Version that only sorts int (134 chars): ``` int[]S(int[]i){var l=0;while(!i.All(e=>{var r=e>=l;l=e;return r;})){i=i.OrderBy(a=>Guid.NewGuid()).ToArray();l=0;}return i.ToArray();} ``` [Answer] # GNU/BASH 65 ``` b(){ IFS=$'\n';echo "$"\|sort -C&&echo "$"\|\|b $(shuf -e "$@");} ``` [Answer] ## C++11, 150 characters ``` #include<deque> #include<algorithm> void B(std::deque &A){while(!std::is_sorted(A.begin(),A.end())std::random_shuffle(myvector.begin(),myvector.end());} ``` Just.. made for fun. [Answer] # C++14, 158 bytes ``` #include <algorithm> #include <random> [](inta,int s){std::random_device r;for(std::knuth_b g(r());!std::is_sorted(a,a+s);std::shuffle(a,a+s,g));return a;}; ``` [Answer] ## Python - 61 chars Recursive ``` from random import;f=lambda l:l==sorted(l)or shuffle(l)>f(l) ``` [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~85~~ ~~82~~ ~~56~~ ~~55~~ 52 bytes -26 bytes thanks to mazzy's suggestions -1 byte thanks to AdmBorkBork -3 bytes thanks to mazzy ``` for($l=$args;"$l"-ne($l\|sort)){$l=$l\|sort{random}}$l ``` [Try it online!](https://tio.run/##JclNCoAgEEDhvaeIGCphWtjPKjyMkNZiyhiDFubZrWj5vnf4y3JYLVEGp2N2nhsgDYaXMJVAZbvbF@7g@ZQyfuuPyGaf/ZYSUBZJiApc0SjssMcBRynq@qfxpQEV9jI/ "PowerShell – Try It Online") PowerShell does have a relatively cheap array comparison by casting them to strings and comparing that. [Answer] # [Go 1.20+](https://go.dev), 95 bytes ``` import(."math/rand";."sort") func f[T Interface](I T){for!IsSorted(I){Shuffle(I.Len(),I.Swap)}} ``` [Attempt This Online!](https://ato.pxeger.com/run?1=ZZDPSsQwEMbvfYoxpwRixX8g6j7AgAeheytFYjfZ7domJUkRCX0SL0XwIXwTfRuTdhHRS2bm4_t9meT1bWumj17UT2IroRONzpquN9bnRHWevA9eHV99PSwazUkn_O7ECr0hNzlxUSMsU4OuQZVrQO2lVaKWFUVYs6CMPUJXRJfcUGSh2A1KtZJific1ZRzz4ln0bBwP13z6l15Co72DsoplSY5ZSWIwQ6mHYKUfrIY2KsjGfz7naMNhn2YGj8a0PwSWTXWL5b76C6VNfkEhGXkyrtLB0zhmC5N-KS4SMizgejXz4YJf8nN-xk9jLsWCZfc26q2e-8P7pmmp3w) Expects input to implement [`sort.Interface`](https://pkg.go.dev/sort#Interface), which wants: * `Len() int`: gets the number of elements. * `Less(i, j int) bool`: checks whether the element at index `i` is less than the element at index `j`. * `Swap(i, j int)`: swaps elements at indexes `i` and `j`. Why is this `1.20+`? See below. ### [Go](https://go.dev), 158 bytes, seeded ints (pre-1.20) ``` import(."math/rand";."sort";."time") func f(I[]int)[]int{Seed(Now().Unix()) for!IntsAreSorted(I){Shuffle(len(I),func(i,j int){I[i],I[j]=I[j],I[i]})} return I} ``` [Attempt This Online!](https://ato.pxeger.com/run?1=LU_BisIwFLz3K7I5vUCsuO6CIB485iJC8VR6CJpotHmVmKJQ-iWClAU_wk_xbzZpvbxh5r0Z5t3_9lX3OsvtSe4VsdJgYuy5cj6l2nr6rL0ezd6PQYOUWukPYydxR-cpvQQtojdWUZboGrdEg8gLg571s8mU2sGqugJLN2huwMJZ5b4E-svSqSwEhL1gTXaotS4VlAoD5TEKDD-SmNSI3BRc5MdiEQePtGVt4pSvHRLRflr2rv4HYKRJ1i6YSwQNQ5Uf_sun_JtP2lDi4-m6Af8B) ### [Go](https://go.dev), 131 bytes, unseeded ints (pre-1.20), truly random (post-1.20) ``` import(."math/rand";."sort") func f(I[]int)[]int{for!IntsAreSorted(I){Shuffle(len(I),func(i,j int){I[i],I[j]=I[j],I[i]})} return I} ``` [Attempt This Online!](https://ato.pxeger.com/run?1=LY4_CoMwGMX3nCLNlEBq6T8olA4dsxUcxSFoYmNNlJhM4tRjdJFCD9Gj9DY16vI-3uP9-N7rXdTDt-HZgxcCaq4MULqprYuQ1A59vJPr0-85ZzhCmrv7xnKTo3OE2jFDBEhvMigxS1JlHJm0k7VdMePaqxXx2BI5ZqSL717KSuBKmNHSwGFFSxiwjiUqpSwp00sQGmxPemCF89ZA1i9TJmoaignswM2OcGWwxPPfAz3SPd3RbU8IWJhhmO8f) This solution is marked as both "unseeded" and "truly random" due to a change in Go v1.20 that changed the global, [default random number generator to be seeded "randomly"](https://tip.golang.org/doc/go1.20#:%7E:text=The%20math/rand%20package%20now%20automatically%20seeds%20the%20global%20random%20number%20generator) rather than be default, deterministic `rand.Seed(1)` in pre-1.20 versions. [Answer] # JavaScript, ~~98~~ 92 chars More precisely ECMAScript 2015 (ES6) Minified: ``` let b=r=>{for(;!r.every((o,t)=>o==[...r].sort()[t]);)r.sort(()=>Math.random()-.5);return r}; ``` Invocation: `console.log(b([3, 2, 1, 5, 67, 4, 6, 5, 6, 4]))` Not minified: ``` let bogoSort = (myArray) => { while (!myArray.every((v, i) => v == [...myArray].sort()[i])) { myArray.sort(() => Math.random() -0.5) } return myArray } ``` Explanation: * `myArray.every()` is an element-wise compare function. Comparing shuffled with sorted array * `someArray.sort()` sorts in place so saving assignments, but also needs cloning for the sorted array * `[...myArray]` clones the array ([array destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment)) * `() => (Math.random() > .5) ? 1 : -1` is a custom compare function. Coin flip whether to order an element in front or behind [Answer] # Javascript 291 characters min ``` function f(e){var t=[].concat(e).sort();t.e=function(e){var n=true;t.forEach(function(t,r){if(t!=e[r])n=false});return n};while(!t.e(e.sort(function(){return Math.floor(Math.random()2)?1:-1}))){console.log(e)}return e} ``` un-min ``` function f(a) { var b = [].concat(a).sort(); b.e = function (z) { var l = true; b.forEach(function (v, i) { if (v != z[i]) l = false; }); return l }; while (!b.e(a.sort(function () { return Math.floor(Math.random() 2) ? 1 : -1; }))) { console.log(a); } return a; } ``` [Answer] # Python, 71 characters ``` from random import* def b(l): while l!=sorted(l):shuffle(l) return(l) ``` Not the shortest one, but it works. Ungolfed: ``` from random import * def bogosort(list): while list != sorted(list): shuffle(list) return(list) ``` Usage: Input: `b([1, 7, 3, 9, 2])` Output: `[1, 2, 3, 7, 9]` [Answer] # Matlab, 59 bytes Relatively straight forward approach: ``` x=input('');while~issorted(x);x=x(randperm(numel(x)));end;x ``` [Answer] # J, 22 bytes ``` $:@({~?~@#)`]@.(-:/:~) ``` This is a recursive, tacit monad using an agenda. Here's how it works: Let `y` be our list. First, the verb on the right of the agenda is `-:/:~`. This a verb graciously provided by [Leaky Nun](http://chat.stackexchange.com/transcript/message/30115841#30115841). It matches (`-:`) whether or not the input is sorted (`/:~`) using a monadic hook. (`(f g) y = y f (g y)`) This returns a one or a zero accordingly. The left hand side of the agenda is a gerund of two verbs: on the right is the identity verb `]`, and on the left is where the recursion takes place. The agenda selects either the identity verb at position `1` if the list is sorted, and the longer verb at position `0` if the list isn't sorted. `$:@({~?~@#)` calls `$:` (the longest verb it is contained in) atop the result of `{~?~@#` on `y`. This shuffles the list, as `?~@#` takes the permutations of the length of `y`, being randomly-sorted indices of `y`. `{~`, in a monadic hook, returns a list from `y` whose indices are the right arg. This shuffled list is then called again with the agenda, and repeats until it is sorted. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes, language postdates challenge ``` ẊŒ¿’$¿ ``` [Try it online!](https://tio.run/nexus/jelly#ASUA2v//4bqKxZLCv@KAmSTCv////1s1LDEsMCw0LDdd9W5vLWNhY2hl "Jelly – TIO Nexus") ## Explanation ``` ẊŒ¿’$¿ ¿ While Œ¿’$ the input is not in its earliest possible permutation (i.e. sorted) Ẋ shuffle it ``` `Œ¿` assigns a number to each permutation of a list; 1 is sorted, 2 has the last two elements exchanged, etc., up to the factorial of the list length (which is the list in reverse order). So for a sorted list, this has the value 1, and we can decrement it using `’` in order to produce a "not sorted" test that's usable as a Boolean in a while loop condition. The `$` is to cause the condition to parse as a group. [Answer] # C++, 166 bytes Meh. ``` #import<algorithm> #import<random> #define r b.begin(),b.end() template<class v> v f(v b){auto a=std::mt19937();while(!std::is_sorted(r))std::shuffle(r,a);return b;} ``` This should work on all STL containers that have `begin()` and `end()`. Ungolfed: ``` #include <algorithm> #include <random> template <class v> v f(v b) { auto a = std::mt19937(); while (!std::is_sorted(b.begin(),b.end())) std::shuffle(b.begin(),b.end(),a); return b; } ``` [Answer] # [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 15 bytes ``` (?⍨∘≢⊇⊢)⍣{⍺≡∧⍺} ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/X8P@Ue@KRx0zHnUuetTV/qhrkeaj3sXVj3p3Pepc@KhjOZBR@z/tUduER719j/qmevo/6mo@tN74UdtEIC84yBlIhnh4Bv8HaswFqgIZZsaVppALAA "APL (Dyalog Extended) – Try It Online") [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 5 bytes ``` ∈&ṣ≤₁ ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r/qG3Do6bG8v@POjrUHu5c/KhzCZD7/3@0kY6xjoGOqY5hLAA "Brachylog – Try It Online") When I first saw ais523's Brachylog answer (as opposed to his Jelly answer, because if I'm not mistaken user62131 was also him), I wondered, what if it used backtracking instead of recursion? So at first, I tried `ṣ≤₁`. Turns out, since choosing something at random doesn't produce multiple outputs so much as it just produces one output nondeterministically, the shuffle predicate `ṣ` can't be backtracked to, so running that will simply fail unless you're lucky enough to shuffle it right on the first try. After that, I tried `pṣ≤₁`, which worked most of the time, but since a finitely long list has finitely many permutations, it still failed at random sometimes. After having abandoned the goal of achieving length reduction, I finally came up with this: ``` The input ∈ is an element of an unused implicit variable, & and the input ṣ shuffled randomly ≤₁ which is increasing is the output. ``` [(Demonstration of randomness)](https://tio.run/##SypKTM6ozMlPN/r//1FHh9rDnYurH@7qVKt91LnkUVPj///RRjrGOgY6pjqGsQA) Although it actually can be a bit shorter if we take some liberties with I/O... # [Brachylog](https://github.com/JCumin/Brachylog), 4 bytes ``` ⊆ṣ≤₁ ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r/qG3Do6bG8v@Putoe7lz8qHMJkPf/f7SRjrGOmY6pjmEsAA "Brachylog – Try It Online") In order for the output to be useful, the input must not contain any duplicate elements, because in addition to sorting the input, this bogosort predicate adds in a random number of duplicate elements and zeroes. (Hypothetically, it could add in anything, but it just kind of doesn't.) Ordinarily I wouldn't bother mentioning something so far from correctly functioning, but I feel it's in the spirit of the challenge. ``` ⊆ An ordered superset of the input ṣ shuffled randomly ≤₁ which is increasing is the output. ``` [Answer] # [Perl 6](https://github.com/nxadm/rakudo-pkg), 28 bytes ``` {({.pick()}...~.sort).tail} ``` [Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WqNaryAzOVtDS7NWT0@vTq84v6hEU68kMTOn9n9xYqVCmkK0oY6xjlGs9X8A "Perl 6 – Try It Online") Anonymous code block that shuffles the list until it is sorted. Note that it sorts the list at least once, which is allowed. And no, the `{.pick()}` can't be replaced with `.pick()` [Answer] # [Pyth](https://github.com/isaacg1/pyth), 11 bytes ``` Wn=Q.SQSQ;Q ``` Pretty happy with this, probably can be golfed a bit more # Explanation ``` Wn=Q.SQSQ;Q W While =Q.SQ Variable Q (input variable) shuffled n Does not equal SQ Variable Q sorted ; Do nothing (loop ends) Q And output variable Q ``` [Try it online!](https://tio.run/##K6gsyfj/PzzPNlAvODA40Drw//9oCx0zHZNYAA "Pyth – Try It Online") ]
[Question] [ # Challenge Write a program or function that converts a 32 bit binary number to its [quad-dotted decimal](https://en.wikipedia.org/wiki/Dot-decimal_notation) notation (often used for representing IPv4) # Quad-dotted decimal A quad-dotted decimal is formed like so: 1. Split the binary representation into its 4 individual bytes 2. Convert each byte into denary 3. place "." between each number Example: ``` input: 10001011111100010111110001111110 step 1: 10001011 11110001 01111100 01111110 step 2: 139 241 124 126 step 3: 139.241.124.126 ``` # I/O examples ``` input --> output 10001011111100010111110001111110 --> 139.241.124.126 00000000000000000000000000000000 --> 0.0.0.0 01111111000000000000000000000001 --> 127.0.0.1 11000000101010000000000111111111 --> 192.168.1.255 ``` # Rules * Input will always be a 32 bit binary number or a binary list or string * [Standard I/O](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) rules apply * No [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins [Answer] # x86-16 machine code, IBM PC DOS, ~~54~~ ~~47~~ 45 bytes Binary: ``` 00000000: be82 00b3 04b1 08ac d0d8 d0d4 e2f9 8ac4 ................ 00000010: 41d4 0a50 8ac4 84c0 75f6 580c 30b4 0ecd A..P....u.X.0... 00000020: 10e2 f74b 7406 b02e cd10 ebd9 c3 ...Kt........ ``` Build and test `BIN2IP.COM` using `xxd -r` from above. Unassembled listing: ``` BE 0082 MOV SI, 82H ; command line input address B3 04 MOV BL, 4 ; loop 4 bytes BYTE_LOOP: B1 08 MOV CL, 8 ; loop 8 bits BIT_LOOP: AC LODSB ; load next bit char into AL D0 D8 RCR AL, 1 ; put LSB of char into CF D0 D4 RCL AH, 1 ; put CF into LSB of byte value, then shift left E2 F9 LOOP BIT_LOOP ; continue bit loop 8A C4 MOV AL, AH ; put byte result into AL GET_DIGIT: D4 0A AAM ; byte divide by 10, AH = AL / 10, AL = AL % 10 50 PUSH AX ; save remainder in AL on stack 8A C4 MOV AL, AH ; put quotient back into AL 41 INC CX ; increment decimal digit count D4 C0 TEST AL, AL ; quotient = 0? 75 F6 JNZ GET_DIGIT ; if not, continue looping PRINT_DIGIT: 58 POP AX ; restore digit in AL 0C 30 OR AL, '0' ; ASCII convert B4 0E MOV AH, 0EH ; BIOS write char function CD 10 INT 10H ; write to console E2 F7 LOOP PRINT_DIGIT ; loop until done 4B DEC BX ; is last byte? 74 06 JZ END_LOOP ; if so, don't display a '.' B0 2E MOV AL, '.' ; otherwise display '.' CD 10 INT 10H ; write to console END_LOOP: 75 D7 JNZ BYTE_LOOP ; continue byte loop C3 RET ; exit to DOS ``` Output: [![enter image description here](https://i.stack.imgur.com/JQKyh.png)](https://i.stack.imgur.com/JQKyh.png) A standalone PC DOS executable. Input is command line, output to console. Notes: The "interesting part" (converting binary string to bytes) is about 15 bytes, whereas the rest of code is writing the [`itoa()`](https://en.wikibooks.org/wiki/C_Programming/stdlib.h/itoa) function to convert binary bytes into a decimal string representation for display. * -2 bytes eliminating unnecessary `PUSH/POP` thx to @PeterCordes! [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` 4äC'.ý ``` [Try it online](https://tio.run/##yy9OTMpM/f/f5PASZ3W9w3v//zc0MDAwNDAEAwQTxIIwAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn3lf5PDS5zV9Q7v/a/z39DAwMDQwBAMEEwQC8LgMiAAuKAqDXHIG3LBpAzBECEBAwA). Explanation: ``` 4ä # Convert the (implicit) input-string into 4 equal-sized parts C # Convert each part from binary to an integer '.ý '# Join this list by "." # (after which the result is output implicitly) ``` [Answer] # [C (gcc)](https://gcc.gnu.org/), 48 bytes ``` i;f(n){for(i=4;i--;)printf(".%hhu"+i/3,n>>i8);} ``` Takes as input a 32-bit integer. Thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat) and [gastropner](https://codegolf.stackexchange.com/users/75886/gastropner) for getting this answer where it is now!* [Try it online!](https://tio.run/##hY9BDoIwEEX3nKIhMbQq2gILkwmcxA2ilVlYSANuCGevpSiQKPF389M3r@kU4b0ojEGQVLFOVppimgCGIbBao2ok9Q@bsmz9HR7jvcoy3J4Y9MYi8shR0WeFV@Z1HrEZLrEWJCX8IjjngguXuQ5tLLAwImfwP1ka8WiI6f1fEUsjGX/1nhXuzJOfgOcUSe0aDEjdNkWZaxqcVcBgQtE6itdR8o0c07em1YrY/XrzAg "C (gcc) – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ 6 bytes ``` s8Ḅj“. ``` [Try it online!](https://tio.run/##y0rNyan8/7/Y4uGOlqxHDXP0/v//H22oYwCGhmCMgNhEYWJIIrEA "Jelly – Try It Online") ``` s Slice input list 8 into size 8 chunks Ḅ Convert from binary list to integer j“. Join with dots as the separator Implicit output ``` [Answer] # [PHP](https://php.net/), 26 bytes ``` <?=long2ip(bindec($argn)); ``` [Try it online!](https://tio.run/##K8go@P/fxt42Jz8v3SizQCMpMy8lNVlDJbEoPU9T0/r/f0MDAwNDA0MwQDBBLAjjX35BSWZ@XvF/XTcA "PHP – Try It Online") ### OR taking input as a integer as an anonymous function : # [PHP](https://php.net/), 7 bytes ``` long2ip ``` [Try it online!](https://tio.run/##K8go@G9jX5BRoMClkmb7Pyc/L90os@C/NVdqcka@gkqahkpiUXqepvV/I0NjA3MDMxNj43/5BSWZ@XnF/3XdAA "PHP – Try It Online") [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 46 bytes ``` ""+[IPAddress]"$([Convert]::ToInt64($args,2))" ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0lJO9ozwDElpSi1uDhWSUUj2jk/ryy1qCTWyiok3zOvxMxEQyWxKL1Yx0hTU@n////qhgYGBoYGhmCAYIJYEIY6AA "PowerShell – Try It Online") First takes input `$args` binary string and `[System.Convert]`s it into `Int64`. Uses the .NET type call `[System.Net.Ipaddress]` to parse that Int64 into an IPAddress object, then coerces the `.IPAddressToString()` method by prepending `""+`. [Answer] # [Python 2](https://docs.python.org/2/), 47 bytes ``` f=lambda n,k=-2:k`n`or f(n>>8,k+1)+'.'+`n%256` ``` [Try it online!](https://tio.run/##DcZLDoMgEADQPadg0whFG5hR/CR6FmxaIsGOxNA0PT3tW730zdtBUIqf9/V1f6yc6jg3MMWrI3ec3AtalqGOykhV3Srl6AKddeWzhf3JzZTOQFl4ESi9s5BSFsC2H7pR95ppBgb/sS0iQ0AAtBrNDw "Python 2 – Try It Online") --- # [Python 3](https://docs.python.org/3/), 46 bytes ``` lambda n:('.%d'4%(n.to_bytes(4,"big"),))[1:] ``` [Try it online!](https://tio.run/##hYpBCoMwEEX3OcUQEDMSJNO6EjxJLUVR20A7CSYbT5@irbgqfbOYB@/7JT4cn9PUtOnZvfqhA65VXmZDXlSZKriM7tYvcQyq0rK3d4ka8UL1NdmXd3OEsAThZ8tRFWpS6w8aTogwuRkCWF4XZYiDZdQQRt/IliUmMsaQoY1DV/uIMH8Q3yX96CT2RNsdYecN "Python 3 – Try It Online") Shaving a byte from [David Foerster's `to_bytes` solution](https://codegolf.stackexchange.com/a/197958/20260) using string formatting. [Answer] # [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 6 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py) ``` 8/å'.u ``` [Try it online.](https://tio.run/##y00syUjPz0n7/99C//BSdb3S//@VDA0MDAwNDMEAwQSxIAwlLiUDAgCkxBBuAjZgCFQCkzQEQ4QUDCgBAA) Explanation:* ``` 8/ # Split the (implicit) input-string into parts of size 8 å # Convert each part from a binary-string to an integer '.u '# Join by "." # (after which the entire stack joined together is output implicitly) ``` [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~20~~ 19 [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") -1 thanks to Kritixi Lithos. Full program. Prompts for 32-bit integer, optionally as list of bits. ``` ' '⎕R'.'⍕256\|83⎕DR⎕ ``` [Try it online!](https://tio.run/##pZCxCsIwEIb3PsVtnSq5xKZ9ABdX3yBoFKG2tUmFipugRVBcBBdfLi9SNVBbSwfBfFzg/sv93EWkkTcrRJQsKlMe08oF11xumTtwzflGfb4L2SsfTV7X@4EzjjWj5nA1pz0BRpkp77YO5vyAWE6lUiIrQCeQZnIjYw0i14mn1rmUWwnJHNRKRBEsY60qsCd1EIgFbTT0qbXWUpzah8BftHywZ45fQafZ67sXW9HT1@XjYz8dKFKKGPjodwqkkyMPgoANWUf2kHMeDkPyBA "APL (Dyalog Unicode) – Try It Online") `⎕` console prompt for numeric input `83⎕DR` interpret the bits of that data as 8-bit integers (internal Data Representation type 3) `256\|` convert to unsigned integers (lit. 256-mod of that) `⍕` stringify (makes space-separated string) `' '⎕R'.'` Replace spaces with dots [Answer] # [JavaScript (V8)](https://v8.dev/), ~~49~~ 44 bytes -5 bytes thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld) ``` s=>s.match(/.{8}/g).map(x=>'0b'+x\|0).join`.` ``` [Try it online!](https://tio.run/##RcdLCoAgFEDRrUQTlej1nDWxtWjSF8tIkaBau/0G3dG5owrK6XVYfB7KaBqftCI6UTmYlNc9LWAvz6Jj9y50ExXBmmTbgQxGO8wSZNR2dtY0YGxHW5pyROTI334@@pAyFi8 "JavaScript (V8) – Try It Online") [Answer] # C#7+, ~~117~~ 73 bytes ``` s=>string.Join('.',(new System.Net.IPAddress(s)+"").Split('.').Reverse()) ``` Accepts the bit representation of an IP address to transform it into a four-number notation, converts it to a string array, reverses the elements to account for the endianness differences of machines, then joins them together again with a dot. [Try it online!](https://tio.run/##Sy7WTS7O/O9WmpdsU5qZV6KjUFxSlJmXbqeQpmD7v9jWDsLV88rPzNNQ11PX0chLLVcIriwuSc3V80st0fMMcExJKUotLtYo1tRWUtLUCy7IySwBKdXUC0otSy0qTtXQ1PxvzcUVADSoRCNNwyAp3tDAwMDQwBAMEEwQC8IAagAA) * Reduced to 73 bytes by utilizing the string hack and chaining (c/o @Expired Data) --- # Initial answer, 117 bytes ``` string I(long b){var x=new System.Net.IPAddress(b).ToString().Split('.');Array.Reverse(x);return string.Join(".",x);} ``` Use it like: ``` void Main() { Console.WriteLine(I(0b_10001011111100010111110001111110)); } public string I(long b) { var x = new System.Net.IPAddress(b).ToString().Split('.'); Array.Reverse(x); return string.Join(".", x); } ``` [Answer] # [Japt](https://github.com/ETHproductions/japt), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) ``` ò8 mÍq. ``` [Try it here](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=8jggbc1xLg&input=IjEwMDAxMDExMTExMTAwMDEwMTExMTEwMDAxMTExMTEwIg) [Answer] # k4, ~~18~~ 17 bytes saved a byte by expressing in composed form instead of as a lambda: ``` ("."/:$2/:'4 0N#) ``` original explanation: output is string, quad-dot decimal not supported by k ``` {"."/:$2/:'4 0N#x} { } /lambda with implicit arg x 4 0N#x /cut x into 4 pieces 2/:' /convert each piece to decimal $ /stringify "."/: /join with . ``` called on 2 binaries: ``` {"."/:$2/:'4 0N#x}'(10001011111100010111110001111110b;11000000101010000000000111111111b) ("139.241.124.126";"192.168.1.255") ``` [Answer] # Java 9, ~~97~~ ~~94~~ ~~92~~ 81 bytes ``` s->{for(int i=0;i<32;)System.out.print((i>0?".":"")+Long.parseLong(s,i,i+=8,2));} ``` -2 bytes thanks to @AZTECCO. -11 bytes thanks to @Holger by combining the `Long.parseLong(s.substring(i,i+=8),2)` into `Long.parseLong(s,i,i+=8,2)`. [Try it online.](https://tio.run/##hVFBbsMgELznFStOIDsIkksV1@kH2lxyrHqgDok2dbBlcKQq8ttdjHGjupW6SGh2mWVm4ayuank@fPRFqayFF4XmtgBA43RzVIWG3ZACXCs8QEH3rkFzAssyX@0WfrNOOSxgBwZy6O1yeztWDfX9gLnI8HG9ytj@0zp94VXreO37HaW4FU@Ekw0hLHmuzInXqrF6QNSmmGKSP6QrxrKuzwaRun0vvUjUCl4u3mm08/oGio02nbaOEimEkEKGuMMBjYAE@xNb/BMztvy@96@QP9kTT4Z1Z00xYxPe6ForR9fD8LMnDmMHYvwFNHXr4uC/njgcJmQDk4ThxViM@byjNDRKdv0X) Explanation: ``` s->{ // Method with String parameter and no return-type for(int i=0;i<32;) // Loop `i` in the range [0, 32): System.out.print( // Print: (i>0? // If `i` is larger than 0 (so it's not the first iteration): "." // Print a dot : // Else: "") // Print nothing instead + // Appended with: Long.parseLong(s,i,i+=8,2));} // A substring of the input `s` from index `i` to `i+8`, // (and increase `i` by 8 for the next loop iteration) // Converted from binary-String to integer ``` [Answer] ## Excel. 96 bytes ``` =BIN2DEC(LEFT(A1,8))&"."&BIN2DEC(MID(A1,9,8))&"."&BIN2DEC(MID(A1,17,8))&"."&BIN2DEC(RIGHT(A1,8)) ``` [Answer] # Python 3 (125 bytes) ``` def f(x): y='' for j in range(4): y+=str(int(x[j8:j8+8],2)) if j<4: y+="." return y ``` [Try it online](https://tio.run/##RY3BCsIwEETv/Yqll@xakUR7KMV8iXgQTDQ5pGUbofn62MZiBwYeuzPMmOJ7CJecn8aCxZn6ChYlLUQBOzB4cAH4EV4G2@1fMo2eIqMLEeebP3T94qa7H89E/4yz4K/t3tl69akuJzbxwwFSdlooKaWSqmjHlX4gqpHXLYuOKOcv) [Answer] # [Red](http://www.red-lang.org), 33 bytes ``` func[n][to 1.1.1 debase/base n 2] ``` [Try it online!](https://tio.run/##hYyxDsIwDERn8hWWd8DuyMBHsFoeSuOoLC4K5fvTJqh0QeKdZJ11p8sWy82iaEgXKOntg7jKPAGfVkG0e/@ycz3g0GlJU7Z@GNdHkImIiRu7re5jMByQ/tA6/N34BdfOlnLTnm1gUIFnfvgM4oDHK0ICVy0L "Red – Try It Online") Takes the input as strings. [Answer] # [Burlesque](https://github.com/FMNSSun/Burlesque), 13 bytes ``` 8co{b2}]m'.IC ``` [Try it online!](https://tio.run/##SyotykktLixN/f/fIjm/OsmoNjZXXc/T@f9/QwMDA0MDQzBAMEEsCAMA "Burlesque – Try It Online") ``` 8co #Break into chunks 8 long {b2}]m #Read each chunk as base-2 and turn to string '.IC #Intercalate "." between each and collapse ``` [Answer] # [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax) ``` Ç∩0&→Ö¡ ``` [Run and debug it at staxlang.xyz!](https://staxlang.xyz/#p=80ef30261a99ad20&i=%2210001011111100010111110001111110%22%0A%2200000000000000000000000000000000%22%0A%2201111111000000000000000000000001%22%0A%2211000000101010000000000111111111%22&a=1&m=2) ### Unpacked (9 bytes) and explanation: ``` 8/{\|Bm'.* 8/ Split into length-8 chunks. 4M would work just as well. {\|Bm Convert each chunk to decimal '.* Join with . ``` [Answer] # [Python 2](https://docs.python.org/2/), ~~81~~ \$\cdots\$ ~~58~~ 55 bytes ``` lambda s:'.'.join(`int(s[i:i+8],2)`for i in(0,8,16,24)) ``` [Try it online!](https://tio.run/##hU9BCsIwELznFaGXJhjKbhApgb5EhVY0GNGmNLn4@phNqb0Izh52lhmWmekd737UyXan9Bxel@vAg6mbunl4N4rejVGEozNu156Vlr31M3c8K6BahQel91KmeAsxdILxCgEAAQs2Smwhlcom@IPFhN8vv4DFtMpYZhNXkEkyykwRc@yyg2F8mqmZFXTnBh8 "Python 2 – Try It Online") Saved 3 bytes thanks to [ElPedro](https://codegolf.stackexchange.com/users/56555/elpedro)!!! Lambda function that takes a string of 32 `"0"`s and `"1"`s. [Answer] # [C (clang)](http://clang.llvm.org/), ~~66~~ 61 bytes ``` i;g(m){for(i=32;i--;)++m+=i%8?m2:!printf(".%d"+i/24,m);} ``` [Try it online!](https://tio.run/##hU5db8IwDHz3r7hVQiQthDh8DJZV@yGIh660EIl2qBTtAfHbuzQr4mmarShn@3znfJqfsvrQdc4eRFzJW/nVCJfOjXXTqZVxklRJ6kbrj7iKzdvLuXF1W4pIjfZR4mZmMfE79t75LqrM1ULiRsiPWYPPa1kWzRZLjZ0l9AzsszbbYm76DuH76E4FBBhpikue1aVANLpEmAzLkJBeDv4mT@sVHFJoWP@/9zIWSeIgPWWQdth5xsM6VCnGPO7tcBCBBenPwfnaXrxdFKo7gdAU7bWpoS3diWYx8XyjzIIVm4V/K9IqJLF5DYiJN0bxaq1YmeWS4lnHWmvWHOIJe/QLSP8TNDD5j7n3HEYc8jl4xA8 "C (clang) – Try It Online") Input as an array of integers (bits) Adds current number shifted to the next. Every 8 bits it prints instead of adding. Saved 5 thanks to @gastropner and @ceilingcat [Answer] # [CJam](https://sourceforge.net/p/cjam), 10 bytes ``` l~8/2fb'. ``` [Try it online!](https://tio.run/##S85KzP3/P6fOQt8oLUldT@v//2hDBQMwNARjBMQmChNDEokFAA "CJam – Try It Online") ### Explanation ``` l~ e# Read a line and evaluate it. Pushes list to the stack 8/ e# Split into sublists of 8 elements each. Gives list of sublists 2fb e# Map "base conversion" with extra parameter 2 over the list of sublists '.* e# Join sublists with character ".". Implicitly display ``` [Answer] # [Python 3](https://docs.python.org/3/), 47 bytes ``` lambda n:".".join(map(str,n.to_bytes(4,"big"))) ``` [Try it online!](https://tio.run/##hYpBCsIwEEX3OcWQVUZCSNSV4E0K0tJWI3YSMrPp6SOtlq7EN4t58H6e5ZHoVMdrU1/t1PUt0EU77Z4pkpnabFiKJSfp1s0ysDlb3cW7RsQap5yKAM@scokk5mBGs3y2cESEMRVgiLQsHEsfCS3wkK@6IY01eO@DDyu7LvYR5f@gvsvwowe1pbDeHjbe "Python 3 – Try It Online") [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~45~~ 44 bytes ``` $args\|%{$r+=+$r+"$_"} [ipaddress]::Parse($r) ``` [Try it online!](https://tio.run/##hZDLCsIwEEX3@YpQRttiDZlYXwXBT3AvItXGBxStiaJS@@01pta6ELxDwiUzJwM3O16l0juZpiVs6ITmJcRqqx@tHFRn0jGXA0unIPN9FieJklovomgWKy09UH5ZEDL1CDUKPBc558jRqrEvVxk3oC72xkyEyFCE5gxcv4b5H71gzmx9QfjZ9ktoN4qhxbDBagBtNeO1LDYWDAcjhkz0@wb16YO2aG6/gNX@EKt7QEHeMrk@y8QkB8uqZzK6pGfz0DaBTqtJ23HAeze78vQh/ahGHFKUTw "PowerShell – Try It Online") --- # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 45 bytes Pure PowerShell. It does not use external libs. ``` ($args\|%{($r=2$r%256+"$_")[++$i%8]})-join'.' ``` [Try it online!](https://tio.run/##hZBha4MwEIa/@yuCnE0ybcil6uyg4P8oo3Rb1jmkdbGjHepvt2mctR8Ge4/AS9577uCqw0mb@kOXZQ/vZEWansHW7Oo2aBiYlXoAE6gkDX3Y@HwdhlAE2XPH55@HYk8F7TvPy5lHrCJGUUqJEp0me3WDoRGhuFgKFaNAFduXUj7C8h9dYSlc3UF42/aX0G1Ujw7DCRsBdDW1j3LYUglMM4FCJYlFOWlJQBo3Al6K/db8RAT0udKvR/1mTwebITO6/i6P9mNmL5oPnS7xgf2Gc/11I/nTiPhe118A "PowerShell – Try It Online") Unrolled and commented: ``` $bytes = $args\|%{ # $args is array on character 48 or 49 (bits) $r = 2 $r # one bit shift left # the first operand is integer, so Powershell converts the second operand to an integer $r = $r % 256 # bitwise and 0xFF $digit = "$_" # convert a char 48, 49 to string "0" or "1" respectively $r = $r + $digit # add a digit # the first operand is integer, so Powershell converts the second operand to an integer # now $r is a byte containing 8 bits to the left of the current one $index = ++$i % 8 # 1,2,3,4,5,6,7,0, 1,2,3,4,5,6,7,0, ... ($r)[$index] # represent $r as an array; take an element of this array # index 0 will give $r, other indexes will give $null # Powershell outputs non $null values only # Compare to `Wrtie-Output ($r)[$index]` } # now $bytes is array of not $null elements Write-Output ($bytes -join '.') ``` [Answer] # [Perl 5](https://www.perl.org/), 30 bytes ``` s/.{8}/oct("0b$&").'.'/ge;chop ``` [Try it online!](https://tio.run/##K0gtyjH9/79YX6/aolY/P7lEQ8kgSUVNSVNPXU9dPz3VOjkjv@D/f0MDAwNDA0MwQDBBLAiDy4AA4IKqNMQhb8gFkzIEQ4QEDPzLLyjJzM8r/q9bkAMA "Perl 5 – Try It Online") Search-replaces with regexp that takes eight bits (`0` or `1`) at a time and converts them to their decimal representation with `.` placed after each, but `chop`s off the last `.` char. Using a function named `oct` here seems counter-intuitive since the input string isn't octal. But when the given string starts with `0b` the rest is read as the binary string it is. [Answer] # [Ruby](https://www.ruby-lang.org/), ~~37~~ 34 bytes ``` ->b{(-3..0).map{\|w\|255&b<<w8}?.} ``` [Try it online!](https://tio.run/##KypNqvyfZvtf1y6pWkPXWE/PQFMvN7Gguqa8xsjUVC3JxqZcy6JWy16v9n@BQlq0QZKhgYGBoYEhGCCYIBaEEfsfAA "Ruby – Try It Online") [Answer] # [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~28~~ 27 bytes -1 byte thanks to Jo King ``` {chop S:g/.*8/{:2(~$/)}./} ``` [Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Ojkjv0Ah2CpdX09Ly0K/2spIo05FX7NWT7/2f3FipYIeUFVafpGCDZehgYGBoYEhGCCYIBaEwWVAAHBBVRrikDfkgkkZgiFCAga47P4DAA "Perl 6 – Try It Online") [Answer] # [J](http://jsoftware.com/), 18 bytes ``` ' .'rplc~&":_8#.\] ``` [Try it online!](https://tio.run/##y/r/P83WSl1BT72oICe5Tk3JKt5CWS8m9n9qcka@QpqCoYIBGBqCMQJiE4WJIYv8BwA "J – Try It Online") ## Old answer -2 thanks to Kritixi Lithos ``` ' .'rplc~&":2#.4 8$] ``` [Try it online!](https://tio.run/##y/r/P83WSkNdQU@9qCAnuU5NycpIWc9EwUIlVvN/anJGvkKagoGCIQo0IAkackGNgWk0RDMQmyhMDFnkPwA "J – Try It Online") My first answer in a non-esolang! (kinda). The way this answer works is pretty simple. Let's look first at a non-tacit form of this expression: ``` (":#.(4 8 $ n))rplc' .' ``` Assuming that (for instance) n is: ``` n =: 1 0 0 0 1 0 1 1 1 1 1 1 0 0 0 1 0 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 ``` The expression `4 8 $ n` is equal to: ``` 1 0 0 0 1 0 1 1 1 1 1 1 0 0 0 1 0 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 ``` Then, the `#.` verb is applied over the matrix, yielding the following result: ``` 139 241 124 126 ``` The resulting list is stringified using `":`, and using `rplc` every space in the string representation of list is swapped to a dot, yielding the final form: ``` 139.241.124.126 ``` [Answer] # REXX, 91 bytes ``` PARSE ARG WITH 1 A 9 B 17 C 25 D SAY X2D(B2X(A))'.'X2D(B2X(B))'.'X2D(B2X(C))'.'X2D(B2X(D)) ``` [Online REXX interpreter](https://www.tutorialspoint.com/execute_rexx_online.php) [Answer] # [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 130 bytes. Requires a Forth that starts in decimal mode, works with gforth. ``` : p . 8 emit ." ." ; : d dup 255 and swap ; : r 8 rshift d ; : q 32 2 base ! word number drop d r r r drop decimal p p p . ; ``` [Try it online!](https://tio.run/##hY1BDoMgEEX3nuK3@xqgMWl02Rt4AyxQTarioPH4FLDWTZO@IeGT/8KYkeb28jTx8r6ERY4bdN/NyM/xVFkJBbVYiKKAHBTcKi0qJEJJwSfXdmYOXrQnXAUEGuk0TlhHUhiWvtEERaMNEqXZHvrR9fIV1tq0uvITOGOMM544YkxbyO51NoH94WPx7z@/4Ju19zzN0e74Nw "Forth (gforth) – Try It Online") Usage:* q 10001011111100010111110001111110 [enter] Deobfuscated version (or how I would really do it) ``` \ Forth program to convert a binary IP address to dotted decimal notation. decimal : binary 2 base ! ; \ Get the binary string and convert to a number. : getbin 32 binary word number drop ; \ Shift and mask the byte we are interested in. Put all 4 on the stack. hex : mask rshift dup ff and ; : quad4 dup ff and swap ; : quad 8 mask swap ; : 3more quad quad quad ; \ Print a quad, backspace over it's trailing space, print a dot. : .quad . 8 emit ." ." ; \ Print all 4 quads in decimal. : .4quads decimal .quad .quad .quad . ; \ Get binary number, chop it up into 4 quads, print in decimal. : qdot getbin quad4 3more drop .4quads ; ``` ]
[Question] [ ## Challenge Robin likes having his variables declaration in the shape of an arrow. Here's how he does it: * Input any number of strings * Order them by ascending length * Output them ordered by the middle to roughly form a negative arrowhead, like this (whichever order golfs the best): ``` 5 or 4 3 2 1 1 2 3 4 5 ``` ## Test Cases Input: ``` bow arrows sheriffOfNottingham kingRichard maidMarian princeJohn sherwoodForest ``` Output: ``` sheriffOfNottingham kingRichard maidMarian bow arrows princeJohn sherwoodForest ``` Input: ``` a bb cc ``` Output (both are valid): ``` bb a cc cc a bb ``` Input: ``` one four seven fifteen ``` Possible output (the only other valid output is its vertical mirror): ``` seven one four fifteen ``` ## Notes * The strings are in camelCase and have no numbers or special characters, only lowercase and uppercase letters. * The input can be anything you like: comma-separated as one string, array, ... Any I/O format is allowed. * Between strings with the same length, any order is accepted. [Answer] # [Python 2](https://docs.python.org/2/), 47 bytes ``` lambda l:l.sort(key=len)or l[1::2][::-1]+l[::2] ``` [Try it online!](https://tio.run/##NU6xjsIwDN35CisLoJaTYIzUGxlOujvp1pAhbZNLRBqjJFLF1xcb6PLs5/ee7du9ekynxXWXJZqpHw1EGT8K5rq72nsXbdpjhqiOUp60kvJw1E1UTJZqSy3QgVKieJuDc7/uB2sN6d@bSbTiSt1fGLzJI7HJhPHb5GASkR5nQpMzzoWaWw5psF/oWeNlM@J4xkwXhG5BCcOZnmAYXoNGtCCaN66lEVpvHP3Lr0FIz1rkBoAP1CdtYXv43NKIfTEkyz63Y2nPztXL0hpcHg "Python 2 – Try It Online") [Answer] # [R](https://www.r-project.org/), ~~63~~ 48 bytes ``` function(L)c(rev(o<-L[order(nchar(L))]),o)[!0:1] ``` [Try it online!](https://tio.run/##HYw9C8IwFAD3/IqaKYEWdJW6OkhVcK0dnvkwQfpeeYnm58fqdMNxx9U3fddU/0aTI6EatFHsPor6bhiJrWOFJgCvQk@6JT1utvvdVA1k5VUygKqVUus2ueUg7yi1eFARwEwliRQcR@@v/kI5R3wGmMVr5S3@nlbMEO0ZOAKKhSMad6KA/6oQ2SOxS1nULw "R – Try It Online") Sort by string lengths, then combine the reversed list with the sorted list, finally, take every 2nd element, starting at 1-based index 1. [Answer] # Javascript 77 bytes Takes input as an array of strings, outputs an arrow-sorted array of strings. ``` s=>s.sort((a,b)=>a.length-b.length).reduce((m,x,i)=>i%2?[...m,x]:[x,...m],[]) ``` ## Explanation ``` s => // take input as an array of strings s s.sort((a,b)=>a.length-b.length) // sort input by string length .reduce( // reduce (m,x,i)=>i%2?[...m,x]:[x,...m], // if index is even, stick string x at the end of the memo // array, else at the beginning [] // memo initialized to empty array ) ``` [Answer] # [Ruby](https://www.ruby-lang.org/), 51 bytes ``` ->l{r=1;l.sort_by!(&:size).map{l[r-=2]\|\|(l2)[~r]}} ``` [Try it online!](https://tio.run/##VY3NDoIwEITvPgX2YEB@Ejlq8OjBRE28ksa00EojULItIQj46rUkauLl25ndnV1oaW94YsJ9OUCy2ZWRkqBvtF@6q60ST@ZFFWmGMoUwifE4uuU69tIX4GkyTauVw9MUqYKB4PzCz1JrUd8LUqEAPay6iqwgkFtXEZGfCAhSW0NlZ0kAZKesaEDUGTvKYp7Nxzop84MEpjTCePH7Q@Yotciyv76PAgf5H36Lb1fMGw "Ruby – Try It Online") [Answer] # [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 89 bytes ``` n=>(n=n.OrderBy(x=>x.Length)).Where((a,b)=>b%2>0).Reverse().Concat(n.Where((a,b)=>b%2<1)) ``` [Try it online!](https://tio.run/##bY1BSwMxFITv@zMCQh6soXrtJoeKBYta6KUH9ZDNvjSh7ou8pG5F/O3rLuJJbzPDzDcuX7ocx/WJXHN3S6ce2bav2OTCkQ6m/iczXo@kjSRNassd8upDnrU5q3ukQwkAah@QUUpbt6BNe3FtFqB2@I6cUYK6SeRskfSn1lwBjMtqz7Gg/DlTmxRJimcStZeEw9PLZyXaNIi6EpY5DXlWeQJF77f@MZUyrYLt5/g4yV10wXI3297G7sFytDS7twnvcJMC/RKGlLp1YsxFVF8AsKzGbw "C# (Visual C# Interactive Compiler) – Try It Online") [Answer] # [K (oK)](https://github.com/JohnEarnest/ok), 24 bytes Solution:* ``` x(<#:'x)(\|&~w),&w:2!!#x: ``` [Try it online!](https://tio.run/##y9bNz/7/v0LDRtlKvUJTo0atrlxTR63cykhRUbnCSkMpKb9cyVopsagov7wYyCjOSC3KTEvzT/PLLynJzEvPSMwFimYDWUGZyRmJRSlAXm5iZopvYlFmYh6QU1CUmZec6pWfkQfVXZ6fn@KWX5RaXKKk@f8/jS0AAA "K (oK) – Try It Online") Explanation: Generate the `6 4 2 0 1 3 5` sequence, use that to index into the ascending lengths of input, and use that to index into the original array: ``` x(<#:'x)(\|&~w),&w:2!!#x: / the solution x: / save input as x # / count (#) of x ! / range 0 to ... 2! / modulo 2 w: / save as w & / indices where true , / join with ( ) / do this together ~w / not (~) w & / indices where true \| / reverse ( ) / do this together #:'x / count (#:) of each (') x < / indices to sort ascending x / index into x ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~9~~ 8 bytes ``` LÞŒœm"-Ẏ ``` [Try it online!](https://tio.run/##y0rNyan8/9/n8Lyjk45OzlXSfbir7//D3VsOt0f@/5@UX86VWFSUX17MVZyRWpSZluaf5pdfUpKZl56RmMuVDaSDMpMzEotSuHITM1N8E4syE/O4Cooy85JTvfIz8sC6yvPzU9zyi1KLSwA "Jelly – Try It Online") ``` LÞŒœṚ;¥/ ``` is also 8 bytes. Thanks to @EriktheOutgolfer and @JonathanAllan for both offering golfs to save a byte. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), ~~6~~ 5 bytes Saved 1 byte thanks to Kevin Cruijssen I/O is a list of strings. Link is modified for newline separated I/O for easier testing. ``` éι`Rì ``` [Try it online!](https://tio.run/##Hcu7CYAwEADQ/gazEFRwAs98zCHm5BJI40KCC4id6V0pitWrHgccyZSt5P05hz4f5b7KyAlQhFOA4IyQtZ1tOUbyk8MF5s@elEPRsCDpBoXQwyrklanZ@X8lZl2xmBBf "05AB1E – Try It Online") Explanation ``` é # sort by length ascending ι # uninterleave into 2 parts, both sorted ascending ` # push the 2 parts separately to the stack R # reverse the second part ì # and append it to the first ``` [Answer] # [J](http://jsoftware.com/), 11 bytes ``` ,~`,/@\:#&> ``` [Try it online!](https://tio.run/##HYu9CsIwFEb3PsWHgkWIUddqiyB0EH@gs6CxTUyU5spNIZuvHovD4SznvNJE5gZlgRwCKxQjC4l9c6yT@N7FcnctprMqzbNQSmw38rYeywdFKGaKAcFqdsZczJmGwfmnVT3eoxvXWsUdeuW6k2KnPD7sfKsPZP3/ikRdTazDkGeZbi2hgkFIPw "J – Try It Online") We sort it down first. Then we reduce the list form right to left, but alternating which side we put the new element on. Done. [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 66 bytes ``` 1..($a=$args\|sort l).count\|?{$_%2}\|%{$a[-$_];$x=,$a[-++$_]+$x};$x ``` [Try it online!](https://tio.run/##FYhLCoMwEECv0sVItNFA3Yr0ICISZNRCyEgSq2A8@xhX77PSjs4vaAzzR6kcdAvazT56cuFl3oUaabMhfk8YsvqK2Qm6q2DoGzja8nEpU0k4rnSYWZBFwWKizT34TQHRJvP4T7wB "PowerShell – Try It Online") Takes input via splatting, which manifests on TIO as separate command-line arguments. `sort`s on the `l`ength, stores that into `$a`, and constructs a range from `1` up to the `count` of input strings. We then pull out only the odd ones `?{$_%2}` and feed those into a loop `\|%{...}`. Each iteration, we put the "last", then the "third from last", and so on onto the pipeline with `$a[-$_]`. Separately, we also accumulate into `$x` the "second from last", "fourth from last", etc. Out of the loop and the pipeline is flushed (so those elements are output) and then we output `$x`. In both instances, the default output gives us newlines between items automatically. [Answer] # [PHP](https://php.net/), ~~144~~ 141 bytes ``` function($a){usort($a,function($b,$c){return strlen($b)-strlen($c);});$e=[];foreach($a as$d)(array_.[unshift,push][++$i%2])($e,$d);return$e;} ``` [Try it online!](https://tio.run/##RZBBTwMhEIXP7q/ggNklRWO8YuNJY4zaxutm07DsIMQWyMDamKa/fQXbTS/wvcfkzQzBhOnhMZhAANHjBiF4TNZ9NXdMEKqXkx6dSta7hkp2GGN@zcQvbs@pYgeENKIjMeEWisluZlRMHJmgsGw7oT2CVCYHEBnpwBqJKH83t@3oorE68TBG07WLBbXX9x1rKPBcJU7hFMRxEhVNEFMkS9JWhLR17/c1J3UO8vtYKBpAq/VKf/hUFjFyV@zvjJ9WGYlDkTtph3eJVrqiAlqn4NUbNyfsvR@e87Qx1R3/byRrXvd9PpSaLe8ga@1HzFeEH3BF5j0gU67pRFXNK5Pz3DJmIowcqitQxhO7C1s/QEPWL@vN0@qN509vTiWMX8wziOo4/QE "PHP – Try It Online") -3 bytes thanks to [@Ismael Miguel](https://codegolf.stackexchange.com/users/14732/ismael-miguel)! [Answer] # MATLAB, 87 bytes ``` function f(y);[B,I]=sort(cellfun(@(x)length(x),y));{y{flip(I(1:2:end))},y{I(2:2:end)}}' ``` Takes input as cell array of strings, outputs column of strings (not sure if that's legal) ``` > s = {'qweq qwe qw','qweqw','12132132131231231','asdasdasda','qwe','w'}; > f(s) > >> > ans = > > 6×1 cell array > > {'qweq qwe qw' } > {'qweqw' } > {'qwe' } > {'1234' } > {'asdasdasda' } > {'12132132131231231'} ``` PS: Thanks Sanchises for pointing to a bug with odd-length inputs [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 18 [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") ``` {⍵[⍋-@(2∘\|)⍋⍋≢¨⍵]} ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR79boR73dug4aRo86ZtRoAtkg1Lno0AqgVGzt/7RHbRMe9fY96pvq6f@oq/nQeuNHbROBvOAgZyAZ4uEZ/B8okKYANsn@Ue8KoF6wTp1DK3RigEoSAQ "APL (Dyalog Unicode) – Try It Online") Fixed the bug thanks to @ngn. Explanation: ``` {⍵[⍋-@(2∘\|)⍋⍋≢¨⍵]} { } ⍝ Function. Takes a single argument: ⍵, list of strings ≢¨⍵ ⍝ The length of each element in the list ⍋⍋ ⍝ Sort the lengths -@(2∘\|) ⍝ At (@) elements divisible by 2 (\|), negate (-) ⍝ gives -1 2 -3 4 -5 ⍋ ⍝ Sort this list again, gives the indices of that list ^ sorted ⍵[ ] ⍝ Use these indices to index into the argument ``` --- [¹](https://github.com/vendethiel/trying.apl/blob/master/ex/arrow-strings.dyalog) [Answer] # APL+WIN, ~~31~~ 38 bytes See Adams comment ``` ⊃n[(⍳⍴n)~a],⌽n[a←2×⍳⌊.5×⍴n←n[⍒∊⍴¨n←⎕]] ``` [Try it online Courtesy of Dyalog Classic!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcjzra0/4/6mrOi9Z41Lv5Ue@WPM26xFidRz1786ITgSqMDk8Hifd06ZmCWFvygGJ50Y96Jz3q6AJyD60ACQCNi439DzTqfxqXuqGRugKQMDbBR5mamVsQZgIA "APL (Dyalog Classic) – Try It Online") Prompts for a nested vector of strings [Answer] # [Retina](https://github.com/m-ender/retina/wiki/The-Language), 26 bytes ``` N$` $.& \,2,^A`.+ ,2,G`.+ ``` [Try it online!](https://tio.run/##HctBCoMwEEDR/ZwjuKgi2Bt0Y0FQwbWIU5M0g5iRSSDHT0NX72@@mEgeu5wntYNqK3iszbPZXntbQ4l3MecPJ0ARTgGCM0LWznbiWM6vwwvO4kKHQ9FwIekRhdDDLeQPM7Dz/ysx657FhPgD "Retina – Try It Online") Explanation: ``` N$` $.& ``` Sort the lines in ascending order of length (`$.&` returns the length of the line). ``` \,2,^A`.+ ``` Temporarily delete alternate lines and output the remaining lines in reverse order. ``` ,2,G`.+ ``` Keep the only lines that were temporarily deleted and output them. [Answer] # [Gaia](https://github.com/splcurran/Gaia), 10 bytes ``` el∫v:v+2%ụ ``` [Try it online!](https://tio.run/##S0/MTPz/PzXnUcfqMqsybSPVh7uX/v8f/ahhTlJ@@aOGuQpAVmJRUX55MZRTnJFalJmW5p/ml19SkpmXnpGYC5XJBvKCMpMzEotSoCK5iZkpvolFmYl5UIGCosy85FSv/Iw8JNPK8/NT3PKLUotLgIKxAA "Gaia – Try It Online") ``` e \| eval as Gaia code (list of strings) l∫ \| ∫ort by lengths (ascending) v:v \| reverse, dup, reverse + \| concatenate lists 2% \| take every other element ụ \| join by newlines and output ``` [Answer] # Japt, 8 bytes ``` ñÊó g0_w ``` -3 bytes thanks to Shaggy! [Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=8crzIGcwX3c=&input=WyJib3ciLAoiYXJyb3dzIiwKInNoZXJpZmZPZk5vdHRpbmdoYW0iLAoia2luZ1JpY2hhcmQiLAoibWFpZE1hcmlhbiIsCiJwcmluY2VKb2huIiwKInNoZXJ3b29kRm9yZXN0Il0KLVE) [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 49 bytes ``` $args\|sort l\|sort{$_.Length($global:x=-$x2+1)} ``` [Try it online!](https://tio.run/##RY3NCsJADITvfYoeFlcrCnoUvHoQf8AXkLTNdhe3G8muVlCfvcYf8JLMTPgmZ@qQo0Xve2XyZX7vFXATH5E45b747Ls6TjcYmmSLoWo8leAXt@VE3Yr5eDZ69s8sGwisS@p0roGZuihCWtkZszc7SsmFxkIr6UnUwVUWuBbXgqu3wA6CmDO7UOGabPjRHVG9IsaYdKb19wnIrSxlVNU/pICSGLrwm8QrvhuMMwlF9S8 "PowerShell – Try It Online") The double [distillation](https://en.wikipedia.org/wiki/Distillation). [Answer] # T-SQL, 84 bytes Input is a table variable ``` SELECT a FROM(SELECT,row_number()over(order by len(a))r FROM @)x order by(r%2-.5)r ``` [Try it online](https://data.stackexchange.com/stackoverflow/query/1023281/arrow-those-variables) [Answer] # [Perl 6](https://github.com/nxadm/rakudo-pkg), 31 bytes ``` .sort(&chars).sort:{$++%2$--} ``` [Try it online!](https://tio.run/##HY09C8JAEET7/IpFoiTGWFhY@JHSQlDBWpBLsuedml3ZOw1B/O2nsXozxZt5oNznoelgpGEdxlPH4pNRZZS49F8W7zjLhrNxnOefsIyc6kAn8TmdXtlSMjjRIJ1AD9As0arkFpQItw6cQbFaH/Sevbd0MaqB249H28/X0Chb75RYRfAQSxVu2dDfapnrDQs6X0yilYKyhKrqIxP@bp4CDl9IoK32iFSELw "Perl 6 – Try It Online") Sort by string length, then by static sequence 0, -1, 0, -3, 0, -5, ... [Answer] # Javascript 95 Bytes ``` s=>s.sort((x,y)=>x.length-y.length).reduce((a,e,i)=>{i%2?a.push(e):a.unshift(e);return a;},[]); ``` [Answer] # [Red](http://www.red-lang.org), ~~116~~ 101 bytes ``` func[b][sort/compare b func[x y][(length? x)> length? y]collect[forall b[keep take b]keep reverse b]] ``` [Try it online!](https://tio.run/##jY09TwMxDIb3/gorU5nYGcrGgARIXaMMTuI00d3FJ1/Ktb/@6hSQYGNJntd6P4TidqRo3S49belcg/XOLiztMfA0oxB4uJ8vcHV2P1I9tfwMl4cD/PDVBR5HCs0mFhxH8HYgmqHhoGl3Z6FPkqVLt6mLMGRYIYE1aMB4r08IxoGdpdQGq4MvMGb3186V1Jv4LPot2lq7LKmR0j/ynlcNoAivS2/IJCWlj/TOrZV6yjjpdVA6lpBRoqoJS3xDKdinem2gV871O70yxxedWNrv@e0G "Red – Try It Online") [Answer] # perl 5 (`-p0777F/\n/ -M5.01`), 59 bytes ``` for$x(sort{$b=~y///c-length$a}@F){--$\|?$\="$x ".$\:say$x}}{ ``` [TIO](https://tio.run/##HcvBCoIwGADg@x5DdqjDmh1ECKROHgILOnuZurmR7h//Bipmj96KTt/pcxKHLEYFSOedBwwrbYr3wjlv2SBtHzQV26Xcr4zR15nWRUJnkhxoffJiofO2rTE2MBGBCJMnXks0St3VDUIwttdiJM@fD9NqgR0ZhekqgUZY4tDYVl5B2/@aALoSUPpAPuCCAesjc2me5yWvLY@syg7p8Qs) [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~136~~ 128 bytes ``` S(a,b)inta,b;{a=strlen(b)-strlen(a);}f(l,s,o,i,b,e)ints,o;{qsort(s,l,8,S);e=l-1;for(i=b=0;i-l;)o[i++%2?b++:e--]=s[i];} ``` [Try it online!](https://tio.run/##NY89b8MgEIb3/goUKRIfh5R0qkpQ50rd0s31AMh2kCikQDLU8m@nENe38KKH5@4wfDKmlDNWoIn1mVIFlGoxK5lydIPHVBO@RUXEMmIHCQJY0DCsSqpKEPNPCjHjBA5e4EzEIB0/ijFEbKWWB2G5EyR0lrH985tm7HXgvJeps71YSu2DvpX1uAUVJwPIXFREtOZ71xM0P6FajVrxiCum4Zavt4xktZ0LBif7O4QRN0oJxa0VPxKyOuP/HdqIO6vnqm84RFSXPQhkT@tDgRiz5AFbXWNdYMS7ffryu02uH6j@UspH8NMQCy@fF@XLe/4D "C (gcc) – Try It Online") -8 bytes thanks to ceilingcat. The function `f` is the solution. It takes the number of strings, the strings themselves, and the output buffer as arguments (plus four more used internally). [Answer] # [Husk](https://github.com/barbuz/Husk), 11 bytes ``` m!ÖL¹Ċ2§+ṡŀ ``` [Try it online!](https://tio.run/##yygtzv7/qKnx0Lb/uYqHp/kc2nmky@jQcu2HOxcebfj//39SfjlXYlFRfnkxV3FGalFmWpp/ml9@SUlmXnpGYi5XNpAOykzOSCxK4cpNzEzxTSzKTMzjKijKzEtO9crPyAPrKs/PT3HLL0otLgEA "Husk – Try It Online") [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal) `a`, 7 bytes ``` µL;yṘ$" ``` [Try it Online!](https://lyxal.pythonanywhere.com?flags=a&code=%C2%B5L%3By%E1%B9%98%24%22&inputs=abcd%0Aabc%0Aab%0Aa&header=&footer=f%E2%81%8B) Outputs as a list of two lists of lines. The header and footer allow for multiline IO. [Answer] # [Japt](https://github.com/ETHproductions/japt), ~~8~~ 6 bytes Input as an array of lines, output as an array of 2 arrays of lines, one for each half of the list. ``` ñÊó vw ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&header=tw&code=8crzIHZ3&footer=VmO3tw&input=Im9uZQpmb3VyCnNldmVuCmZpZnRlZW4i) (Header & footer allow for I/O as newline separated string) ``` ñÊó vw :Implicit input of array ñ :Sort by Ê : Length ó :Uninterleave v :Modify first element w : Reverse ``` [Answer] # [Julia 1.0](http://julialang.org/), 41 bytes ``` !s=sort(s,by=length)[∪(end:-2:1,1:end)] ``` [Try it online!](https://tio.run/##JYwxbsMwDEV33iKaJCAd3NGB1w4FmgBd2w60RUVsHDKQlLpZMvcsOVYv4srp9D4@@d/neWRsvud5lbusqdi87i/dSLIv0b39/twsiW8fHttm3bQ1uo/5mjvrOZ9GvNhVBdeRc5tTYimjWPMuxjmAqzEGep0AU9IpQ46UOIRd2GopLPuIRzhUvvIQMXk4IvsXTIwCi2qgZ41yX02q/kkT5QKL8y5WIQh6TpDpiwQCh0KVy@n/AaHvYRiWZv4D "Julia 1.0 – Try It Online") * input and output are vectors of strings * `end:-2:1` takes every second index, starting from the end * `1:end` is all indices * `∪` (=`union`) removes duplicates ]
[Question] [ Write two triangle (i.e. pyramid) shaped programs. The first one should be an upwards pointing text triangle with a minimum base width of three characters. So it would have a structure like ``` X XXX ``` or ``` X XXX XXXXX ``` or ``` X XXX XXXXX XXXXXXX ``` or larger. Each of the `X`'s is to be replaced with the characters of your actual code, which may be anything except [line terminators](https://en.wikipedia.org/wiki/Newline#Unicode) (so the `X`'s could be spaces). All the `X`'s must be replaced and the spaces and newlines that help form the triangle shape are required to stay as is. The second program must have the same size and shape as the first, except that the triangle will be pointing down. So if your first program looks like ``` X XXX XXXXX ``` then your second program would look like ``` yyyyy yyy y ``` where each `y` is a character you need to fill in with your actual code (probably different from your `X` code). The spaces and newlines must stay the same here too. Your task is to write these programs such that they each output (to stdout or closest alternative) the title of a distinct [Beatles](https://en.wikipedia.org/wiki/The_Beatles) song, not taking any input. [This Wikipedia article](https://en.wikipedia.org/w/index.php?title=List_of_songs_recorded_by_the_Beatles&oldid=681078214) will serve as our official song list for The Beatles. The output should be one of the titles exactly as listed, e.g. `I Want You (She's So Heavy)`. This is pretty easy, however, even with the weird triangle program requirement. So we're going to form another program from the first two that must output yet another song title. By combining three copies of each of the two triangular programs we can create a third program shaped like a hexagon. If the base width of your first program was three it would look like this: ``` XyyyX XXXyXXX yyyXyyy yXXXy ``` If the base width was five it would look like this: ``` XyyyyyX XXXyyyXXX XXXXXyXXXXX yyyyyXyyyyy yyyXXXyyy yXXXXXy ``` This program (when run with the spaces and newlines like the others) must output another Beatles song title, just like the first two programs. Also: * Your three programs must output different song titles. * Only song titles eight characters in length or longer are allowed. * You can only choose one of `Revolution`, `Revolution 1` and `Revolution 9` because the titles are so similar. * You must choose your three favorite Beatles songs. (Well, try to.) Note that actual programs are required. Functions are not allowed. Reading your own source code in any program is also not allowed. # Example If your first program was ``` A AAA AAAAA ``` it could output `Across the Universe`. Then your second program ``` bbbbb bbb b ``` could output `Revolution`. Then combined into the hexagon program ``` AbbbbbA AAAbbbAAA AAAAAbAAAAA bbbbbAbbbbb bbbAAAbbb bAAAAAb ``` the output might be `Get Back`. # Scoring The submission with the smallest triangle base width wins. In the likely case of ties the submission with the largest summed length of its three song titles wins. [Answer] # [Befunge](http://www.esolangs.org/wiki/Befunge)-93, width = 13 ~~15~~, titles = 31 ~~24~~ chars A power outage last night prevented me from updating this when I figured it out, but I managed to reduce the triangle width and increase the song lengths! ## Pointing-up program: "Dig a Pony", 10 characters: ``` v v> v# > "< v <>"y"v> <v"Dig a P" "^>:#,_@.>"no ``` ### Explanation I REALLY took advantage of Befunge's wrap-around trick and I picked "Dig a Pony" specifically because it had a space at the 6th position. This allows program flow to move through the song name. Try it in the [online interpreter](http://www.quirkster.com/iano/js/befunge.html) to see how it works. ## Pointing-down program: "If I Fell", 9 characters: ``` < v"f I Fell" v>"I">:#,_@ "raC yM " v"Drive . ``` (Period is extraneous and only included to make the other lines show up.) ### Explanation The only relevant lines here are the first two. I used the wrap-around trick (the instruction pointer is sent left immediately) to squeeze in one more character. The second line prints out the song name. ## Combined: "Drive My Car", 12 characters: ``` v< v"f I Fell"v v> v>"I">:#,_@v> v# >"raC yM "v# > "< v"Drive"< v <>"y"v> v <>"y"v> <v"Dig a P" <v"Dig a P" "^>:#,_@.>"no "^>:#,_@.>"no < v"f I Fell"v< v"f I Fell" v>"I">:#,_@v> v>"I">:#,_@ "raC yM "v# >"raC yM " v"Drive"< v"Drive v <>"y"v> <v"Dig a P" "^>:#,_@.>"no ``` Here's the same thing, but with lines added to show the hexagon and triangles. ``` ----------------- /v\< v"f I Fell"/v\ /v> \v>"I">:#,_@/v> \ /v# >\"raC yM "/v# >\ /"< \v"Drive/"< \ /v <>"y"v>\ /v <>"y"v>\ /<v"Dig a P"\ /<v"Dig a P"\ /"^>:#,_@.>"no\ /"^>:#,_@.>"no\ ------------------------------- \< v"f I Fell"/v\< v"f I Fell"/ \v>"I">:#,_@/v> \v>"I">:#,_@/ \"raC yM "/v# >\"raC yM "/ \v"Drive/"< \v"Drive/ \ /v <>"y"v>\ / \ /<v"Dig a P"\ / \ /"^>:#,_@.>"no\ / ----------------- ``` ### Explanation This is where the third and fourth lines of the pointing-down triangle come into play. There are several redirects at the edge of both triangles that serve to move the instruction pointer through those two lines and push "Drive My Car" onto the stack. Then it is printed out using the `>:#,_@` bit in the pointing-up triangle. Incidentally, both the left and the right pointing-up triangles are used. There might be a way to use more of the empty space, but I think my time is better spent on other questions. :P [Answer] # GolfScript, width = 9 chars, titles = 33 chars ## Hexagon ``` "Let It Be" }";"Yeste"}"; "Twi""rda""Twi" "st an""y""st an" "d Shout"}"d Shout" Let It Be"Let It Be "Yeste"}";"Yeste" "rda""Twi""rda" "y""st an""y" }"d Shout"} ``` Prints Let It Be. (9 characters) [Try it online.](http://golfscript.apphb.com/?c=ICAgICJMZXQgSXQgQmUiCiAgIH0iOyJZZXN0ZSJ9IjsgICAgICAKICAiVHdpIiJyZGEiIlR3aSIKICJzdCBhbiIieSIic3QgYW4iCiJkIFNob3V0In0iZCBTaG91dCIKTGV0IEl0IEJlIkxldCBJdCBCZQogIlllc3RlIn0iOyJZZXN0ZSIKICAicmRhIiJUd2kiInJkYSIKICAgInkiInN0IGFuIiJ5IgogICAgfSJkIFNob3V0In0%3D) ### How it works The token `"Let It Be"` on the first line pushes the string Let It Be on the stack. The second line begins with `}`, an undocumented "super comment" that aborts execution immediately. Before exiting, GolfScript prints the contents of the stack. ## X triangle ``` " }"; "Twi" "st an" "d Shout" ``` Prints Twist and Shout. (15 characters) [Try it online.](http://golfscript.apphb.com/?c=ICAgICIKICAgfSI7CiAgIlR3aSIKICJzdCBhbiIKImQgU2hvdXQi) ### How it works The first two lines push the string `"\n }"`, which the command `;` discards from the stack. The remaining lines contain the tokens `"Twi"`, `"st an"` and `"d Shout"`, which push the string Twist and Shout in three pieces. Before exiting, GolfScript prints the contents of the stack. ## Y triangle ``` Let It Be "Yeste" "rda" "y" } ``` Prints Yesterday. (9 characters) [Try it online.](http://golfscript.apphb.com/?c=TGV0IEl0IEJlCiAiWWVzdGUiCiAgInJkYSIKICAgInkiCiAgICB9) ### How it works The tokens `Let`, `It` and `Be` on the first line are undefined, so they do nothing. The three following lines contain the tokens `"Yeste"`, `"rda"` and `"y"`, which push the string Yesterday in three pieces. The `}` on the last line does nothing; the program would have finished anyway. Once more, GolfScript prints the contents of the stack before exiting. [Answer] # Python 2, width = 51 ``` #print "Yellow Submarine" if id else "(Reprise)" ## #.##...............................................##.# #...##.............................................##...# #.....##...........................................##.....# #.......##.........................................##.......# #.........##.......................................##.........# #...........##.....................................##...........# #.............##...................................##.............# #...............##.................................##...............# #.................##...............................##.................# #...................##.............................##...................# #.....................##...........................##.....................# #.......................##.........................##.......................# #.........................##.......................##.........................# #...........................##.....................##...........................# #.............................##...................##.............................# #...............................##.................##...............................# #.................................##...............##.................................# #...................................##.............##...................................# #.....................................##...........##.....................................# #.......................................##.........##.......................................# #.........................................##.......##.........................................# #...........................................##.....##...........................................# #.............................................##...##.............................................# #...............................................##.##...............................................# print "Sgt. Pepper's Lonely Hearts Club Band",;id=0#print "Sgt. Pepper's Lonely Hearts Club Band",;id=0 print "Yellow Submarine" if id else "(Reprise)" ##print "Yellow Submarine" if id else "(Reprise)" # #...............................................##.##...............................................# #.............................................##...##.............................................# #...........................................##.....##...........................................# #.........................................##.......##.........................................# #.......................................##.........##.......................................# #.....................................##...........##.....................................# #...................................##.............##...................................# #.................................##...............##.................................# #...............................##.................##...............................# #.............................##...................##.............................# #...........................##.....................##...........................# #.........................##.......................##.........................# #.......................##.........................##.......................# #.....................##...........................##.....................# #...................##.............................##...................# #.................##...............................##.................# #...............##.................................##...............# #.............##...................................##.............# #...........##.....................................##...........# #.........##.......................................##.........# #.......##.........................................##.......# #.....##...........................................##.....# #...##.............................................##...# #.##...............................................##.# #print "Sgt. Pepper's Lonely Hearts Club Band",;id=0# ``` Yeah, well... Python. Python comments begin with `#`, so the majority of lines is just comments. For the upwards facing triangle, the only thing that executes is ``` print "Sgt. Pepper's Lonely Hearts Club Band",;id=0 ``` which prints `Sgt. Pepper's Lonely Hearts Club Band`. For the downwards facing triangle, we execute ``` print "Yellow Submarine" if id else "(Reprise)" ``` which prints `Yellow Submarine`, since the function `id` is truthy. When we combine the programs however, all that happens is the above two lines in sequence. Since the end of the first line sets `id=0`, which is now falsy, the end result is that we tack a `(Reprise)` to the end, getting `Sgt. Pepper's Lonely Hearts Club Band (Reprise)` as our output (Calvin [said this is okay](https://chat.stackexchange.com/transcript/message/24175567#24175567)). [Answer] ## [Snowman 1.0.2](https://github.com/KeyboardFire/snowman-lang/releases/tag/v1.0.2-beta), width = 13 ``` }?}///////////} ///"Get Back"//// /////////////////// ///////////////////// "Sun King//"[["Sun King ""BirthdaysP/""Birthday "]]8AaLsP[[///"]]8AaLsP[[// ?}///////////}?}/////////// "Get Back"////"Get Back"/ /////////////////////// ///////////////////// //"[["Sun King//"[[ sP/""BirthdaysP/ /"]]8AaLsP[[/// ``` Finally!* A challenge where Snowman can thrive! :D :D The slashes are mostly for aesthetic purposes, and the majority of them can be replaced with spaces (but that would make it look a whole lot more boring). Some slashes are necessary, for comments. ### Program A (output: `Birthday`): ``` } /// ///// /////// "Sun King ""Birthday "]]8AaLsP[[// ``` This one's pretty simple. The first character (`}`) sets up our active variables, then there's a bunch of comments / no-ops. It then stores the string `"Sun King\n "` and immediately discards it (via ``, storing it in a permavar which we never use). Then it stores `"Birthday\n"`. `]]` is a no-op here, since `[[ foo ]]` is a block comment in Snowman, but since there's no matching `[[` before this `]]` (within program A itself), it simply does nothing. Then `8AaL` grabs the first 8 characters of the string, `sP` prints it, and `[[` comments out the rest of the program (because again, there's no matching `]]`. ### Program B (output: `Get Back`): ``` ?}/////////// "Get Back"/ ///////// /////// //"[[ sP/ / ``` This one's also pretty straightforward. `?}` is equivalent to `}` (`?` simply sets all variables to inactive, which is a no-op here but again, important later). Then it stores the string `"Get Back"`, does a bunch of no-ops (`//` to end of line is always a comment), and prints via `sP`. ### Full program Output is, you guessed it, `Sun King`1. Let's look at this line by line: * Line 1 ``` }?}///////////} ``` This sets our active variables, just like the previous programs (we can see now that the `?` is needed so as to not simply toggle them on and then back off with `}}`). The rest of the line is commented out. * Lines 2-4 ``` ///"Get Back"//// /////////////////// ///////////////////// ``` Comments... * Line 5 ``` "Sun King//"[["Sun King ``` Here we store the string `"Sun King//"`, and then start a block comment. This essentially skips everything until the next `]]`. * Line 6 ``` ""BirthdaysP/""Birthday ``` Still inside the block comment... * Line 7 ``` "]]8AaLsP[[///"]]8AaLsP[[// ``` Here we break out of the block comment for a short period of time, to execute the code `8AaLsP`. This is actually reused from program A. Since I chose all songs that are 8 letters long, I can simply use the same code for the combined program. Then it gets a little tricky. The next time we emerge from the block comment, we see `8AaLsP` again. This time, however, all variables are undefined (we called `sp`, print, in consume mode, which gets rid of the variables). Since `aal` requires two arguments, and this time it only has one (`8`), it errors and leaves the variables unchanged. Similarly, `sp` encounters the `8`, realizes it's the wrong type to be printed, and leaves the variables as is. * Lines 8-13 ``` ?}///////////}?}/////////// "Get Back"////"Get Back"/ /////////////////////// ///////////////////// //"[["Sun King//"[[ sP/""BirthdaysP/ ``` Still stuck in that block comment... Line 14 ``` /"]]8AaLsP[[/// ``` Finally, we try calling that same print-first-8-chars sequence once again, and it fails once again, producing another two errors. (The `8` means that the variables are now `8 8`, which is the correct number of variables for `aal` now, but still not the right types.) --- 1: as well as four runtime errors (`SnowmanException`s) to STDERR, but [as per meta that doesn't matter](http://meta.codegolf.stackexchange.com/q/4780/3808). [Answer] # [><>](https://esolangs.org/wiki/Fish), width = 11 ``` /"yadhtri"\ / v"B"/ ?!;>ol duJ yeH" /"eduJ yeH o >l?!; o >l?!; staC"/"klaw staC"/"klaw "yadhtri"\ /"yadhtri"\ v"B"/ v"B"/ ?!;>ol ?!;>ol " /"eduJ yeH" /"e o >l?!; staC"/"klaw ``` 2D languages have a pretty good time with this challenge. ### Upwards arrow ``` / duJ yeH o >l?!; staC"/"klaw ``` Program flow starts from the top-left, moving rightward. The `/` reflects up, and since ><> is toroidal we reappear from the bottom. We then hit another `/` and reflect again, and push the characters `klawstaC` one-by-one to the stack in string `""` mode. Finally, we reflect upwards and hit a `>l?!;o` loop, which is the idiomatic way of printing the entire stack in ><>. This prints `Catswalk`. ### Downwards arrow ``` "yadhtri"\ v"B"/ ?!;>ol " /"e ``` Basically the same thing, pushing the characters from the get go and using mirrors and arrows to direct program flow. This prints `Birthday`. ### Combined ``` / ?!;>ol ?!;>ol /"eduJ yeH" / ``` The relevant parts are above (I've cut out a lot of lines in the middle). Using the `/` from the upwards arrow, we reflect upwards and wrap around, but since we now have the downwards arrow underneath, part of that code is executed instead. We then push the relevant characters to the stack, and reuse the output loop from the downwards arrow. This prints `Hey Jude`. [Answer] # Python 2, size 21 This program requires an ANSI-compatible terminal (DOS [ANSI.SYS](https://en.wikipedia.org/wiki/ANSI.SYS) to be specific), since I use [`\x1b[2J`](https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes) to clear the console AND move the cursor to top-left. To make this compatible with other ANSI terminals, print `\x1b[1J\x1b[H` (this can still fit in a size 21 hexagon). I wasn't able to test this part, because I don't have a terminal that prints ANSI escape codes. I think the program looks pretty cool, similar to the radioactive symbol (though the ASCII shading implies the colors are backwards) or the icon of the sniper weapon from Metroid Prime: Hunters. It did fit in size 17, but I'd forgotten `id=0` in the up arrow. I don't think I can shrink it back down, since that has to all be on one line... Also, credit goes to Sp3000 for the idea to use `id`. ``` #exec('print"' ## ###'\x1b[2J"+(id ' #### #####'and"Hey Ju' ###### #######'de"or"Ca' ######## #########'tswalk' ########## ###########'")') ############ ############## ############## ################ ################ ################## ################## #################### #################### id=0;print"Birthday"##id=0;print"Birthday"# exec('print"' ##exec('print"' # '\x1b[2J"+(id ' ####'\x1b[2J"+(id ' # 'and"Hey Ju' ######'and"Hey Ju' # 'de"or"Ca' ########'de"or"Ca' # 'tswalk' ##########'tswalk' # '")') ############'")') # # ############### # # ################# # # ################### # # ##################### # #id=0;print"Birthday"## ``` ### Up Arrow: ``` # ### ##### ####### ######### ########### ############# ############### ################# ################### id=0;print"Birthday", ``` ### Down Arrow: ``` exec('print"' # '\x1b[2J"+(id ' # 'and"Hey Ju' # 'de"or"Ca' # 'tswalk' # '")') # # # # # # # # # # ``` "Hey Jude" is one of my favorite Beatles songs, but I really don't know that many. I've never heard the other two songs I'm using. It's not a genre I listen to often. [Answer] # [C (gcc)](https://gcc.gnu.org/), base width = 17 ## Top, "Hey Jude" ``` s ;// s;/// main(// ){puts(// #define T// s?"Michell"// "e":"Hey Jud"// "e");}/////////// ``` [Try it online!](https://tio.run/##S9ZNT07@/18BCoq5oAxrfX0osxjIhLJzEzPzNKAczeqC0pJiKE85JTUtMy9VIQTMLbZX8s1MzkjNyVEC8ZVSlayUPFIrFbxKU0ACQL6mda0@Avz/DwA "C (gcc) – Try It Online") ## Bottom, "Matchbox" ``` s=1;///////////// #ifndef T////// main(){puts// ("Matchb"// "ox");}// # endif ///// //\ ; ``` [Try it online!](https://tio.run/##S9ZNT07@/7/Y1tBaHxlwKShnpuWlpKYphMAEFHITM/M0NKsLSkuKwXwFDSXfxJLkjCQlCFdBKb9CSdO6FspTUFZIzUvJTINwFGCmQDkxMKaC9f//AA "C (gcc) – Try It Online") ## Hexagon, "Michelle" ``` ss=1;/////////////s ;//#ifndef T//////;// s;///main(){puts//s;/// main(//("Matchb"//main(// ){puts(//"ox");}//){puts(// #define T//# endif#define T// s?"Michell"///////s?"Michell"// "e":"Hey Jud"////\"e":"Hey Jud"// "e");}///////////;"e");}/////////// s=1;/////////////ss=1;///////////// #ifndef T//////;//#ifndef T////// main(){puts//s;///main(){puts// ("Matchb"//main(//("Matchb"// "ox");}//){puts(//"ox");}// # endif#define T//# endif /////s?"Michell"/////// //\"e":"Hey Jud"////\ ;"e");}///////////; ``` [Try it online!](https://tio.run/##ZZGxDoIwEIb3PkVzLDCYxtXGuBoTNkcWLEWaIJoUEo3x2WsLByncbf3@u1z7Ve3uSjnHsaw97qWIyzKMPE5M3VW65tcp8gRDG2YepenS7PsaeuvHApnSkQuRQl72qrkBdmI8DfgTPN@QyZ8QCwl54veZToeVCdddZeqI@AZ7gtyoRrctzBeOCeOg4QBn/eGXoRpbig1h/jzuXUoSwqgWQhinejaEoYyVpBUJT6aiIjI6o6oWMimnqpDgf1FR8/0wLqi2OeRUj3TuDw "C (gcc) – Try It Online") [Answer] # gawk, base length 15 Just found out it doesn't work with mawk :/ It's not too tricky, but being grown up in the 70s, with The Beatles still omnipresent on air, I had to answer this. First I thought awk wasn't suited, but then it came to me. Since these scripts contain BEGIN- and/or END-blocks, they need to be told that there will be no input to execute the END-block. This can be achieved by either pressing Ctrl-D after starting them, or starting them like this: ``` awk -f script.awk </dev/null ``` which I think is more convenient. `echo \| awk -f script.awk` will also work, but if I would have used an empty line as input I would have done this completely different. ### Pointing up, prints [For No One](https://www.youtube.com/watch?v=OQxnIh8u8o8) (Youtube link) ``` # # # # # BEGIN { print n?# # # n"So Tired":# n="For No One"} ``` The essential code without comments is this. Since `n` isn't defined it prints "For No One" if called by itself. ``` BEGIN { print n? n"So Tired": n="For No One"} ``` ### Pointing down, prints [Blackbird](https://www.youtube.com/watch?v=BrxZhWCAuQw) ``` END{a="Blackb"# a=n?_:a"ird"# printf a # n="I'm "# if(a) # print } # # ``` The essential code is this. If `n` was defined before it doesn't print anything. I enforced the nice output with a newline after every track name, because I had the room to do that and it looks nicer in the console. `n` is defined in the process; that's needed for the Hexagon. ``` END{a="Blackb" a=n?_:a"ird" printf a n="I'm " if(a) print } ``` ### Hexagon, prints [I'm So Tired](https://www.youtube.com/watch?v=-Tu2eZpA4yo) ``` #END{a="Blackb"## # #a=n?_:a"ird"## # # #printf a ## # BEGIN {n="I'm "#BEGIN { print n?#if(a) #print n?# # #print# # n"So Tired":#} #n"So Tired":# n="For No One"}#n="For No One"} END{a="Blackb"##END{a="Blackb"# a=n?_:a"ird"## #a=n?_:a"ird"# printf a ## #printf a # n="I'm "#BEGIN {n="I'm "# if(a) #print n?#if(a) # print# #print } #n"So Tired":#} # #n="For No One"}# ``` The essential code. Now finally that mysterious `n` is used. Because `n` is defined in the first line, the upwards pointing triangle prints the alternative output, and the downwards pointing triangle prints emptiness. ``` BEGIN {n="I'm " print n? n"So Tired": n="For No One"} END{a="Blackb" a=n?_:a"ird" printf a n="I'm " if(a) print } ``` ]
[Question] [ The unnecessary and convoluted story I am walking around [manhattan, block by block](http://en.wikipedia.org/wiki/Taxicab_geometry) and my feet have gotten tired and want to go back home. The traffic is pretty bad, but fortunately I'm very rich and I have a helicopter on standby at the hotel. But I need them to know how much fuel to pack for the flight and for that they need to know my direct distance from the hotel. I did remember which blocks I walked and can tell them what route I took. This distance needs to be precise though, if they are too short we won't make it back, too long and I've bought fuel I can't use. Can you write me a program to convert that into the distance they will have to travel on their flight to fetch me? Specification: Write me a function that: 1. Accepts a list or string of blocks walked relative to an arbitrary grid: * U p, D own, L eft and R ight. * Can be either upper or lower case - eg. if its shorter to use `u` instead of `U` go ahead. * An invalid direction has undefined behaviour - eg. a direction of X can cause a failure. 2. Returns a float/decimal/double that is twice the straight line distance from the point of origin. For illustration and clarification: ![My trip](https://i.stack.imgur.com/2gTOu.png) My trip could have just as easily been recorded as `"luluu..."` or `['l','u','l'...]` but it must be recorded as Up, Down, Left, Right. [Answer] ### J, 17 characters ``` 2\|+/0j1^'urdl'i. ``` Uses the fact, that the powers of `j` represent the proper directions. `'urdl'i.` take string and calculate indices (0 for 'u', 1 for 'r', ...) * `0j1^` transforms into the direction in the complex plane using the corresponding power of `j`. * `+/` sums up the single steps * `2\|` two times the modulus Example: ``` > 2\|+/0j1^'urdl'i.'uuuudrrrl' 7.2111 ``` [Answer] ## Python 2.7 56 58 56 51 48 With the stolen [Number One Dime](http://disney.wikia.com/wiki/Number_One_Dime) from [Scrooge McDuck](http://en.wikipedia.org/wiki/Scrooge_McDuck), I made my fortune and now have more wealth than Scrooge. ``` y=lambda s:2abs(sum(1j(ord(i)%15)for i in s)) ``` ## Python 2.7 - 61 53 50 (case insensitive) ``` y=lambda s:2abs(sum(1j(ord(i)%16%9)for i in s)) ``` Implementation** ``` >>> from random import sample >>> y=lambda s:2abs(sum((-1j)(ord(i)%15)for i in s)) >>> path=sample('RLUD'1000, 100) >>> y(path) 20.0 >>> path=sample('RLUD'1000, 100) >>> y(path) 34.058772731852805 ``` [Answer] ## APL (29) ``` {\|+/2 0j2×-⌿2 2⍴+/'URDL'∘.=⍵} ``` e.g. ``` {\|+/2 0j2×-⌿2 2⍴+/'URDL'∘.=⍵} 'UUUUDRRRL' 7.211102551 ``` Explanation: `+/'URDL'∘.=⍵`: see how often the characters `URDL` occur in the argument * `-⌿2 2⍴`: subtract the `U` value from the `D` value, and the `R` value from the `L` value * `2 0j2×`: multiply the vertical value by `2` and the horizontal value by `2i` * `+/`: sum * `\|`: magnitude [Answer] # Ruby 1.9+ (67) ``` f=->s{2(((g=s.method :count)[?U]-g[?D])2+(g[?R]-g[?L])2)0.5} ``` Example ``` f["DRUULULLULL"] => 10.0 f["UUUUDRRRL"] => 7.211102550927978 ``` [Answer] ## perl6: 44 chars ``` 2abs [+] i <<*>>%(<U R D L>Z ^4){get.comb} ``` `get.comb` gets one line of input and splits into characters * `<U R L D>` is a list of words, chars in this case * `(1,2,3) Z (4,5,6)` == `(1,2), (2,5), (3,6)`, so it zips 2 lists into each other, making a list of parcels that `%()` turns into a hash * `<<>>` does pairwise ``, extending the shorter list to fit the longer. Shorter list happens to only be `i` * `[+]` sums all elements of a list, `abs` takes the modulus for complex numbers Yes, I removed all possible spaces. [Answer] # Mathematica ~~92~~ 49 Calle deserves full credit for streamlining the code. ``` f@l_:=2 N@Norm[Tr[l/.{"r"→1,"l"→-1,"u"→I,"d"→-I}]] ``` Example ``` f[{"u", "u", "u", "u", "d", "r", "r", "r", "l"}] ``` > > 7.2111 > > > [Answer] ## PHP, 67 ``` function f($a){foreach($a as$d)@$$d++;return 2hypot($U-$D,$L-$R);} ``` Example: ``` <?php var_dump(f(array('U', 'U', 'U', 'U', 'D', 'R', 'R', 'R', 'L'))); >float(7.211102550928) ``` [Answer] # Julia, 45 ``` f(l)=2abs(sum([im^(c=='d'?3:c) for c in l])) ``` Stole the `i` to powers trick. Also all the characters except d have values that work as acceptable powers for `i`. [Answer] ## Python 2.7 - 65 Nice and short one, this uses complex numbers to step through the plane: ``` x=lambda s:2abs(sum([[1,-1,1j,-1j]['RLUD'.index(i)]for i in s])) ``` Props to DSM and Abhijit in other questions that showed me the use of `1j` to calculate this. [Answer] ### R, ~~86~~ ~~74~~ 56 characters Ok it's actually way shorter with imaginary numbers indeed: ``` 2Mod(sum(sapply(scan(,""),switch,u=1i,d=-1i,l=-1,r=1))) ``` Usage: ``` > 2Mod(sum(sapply(scan(,""),switch,u=1i,d=-1i,l=-1,r=1))) 1: u u u u d r r r l 10: Read 9 items [1] 7.211103 ``` Old solution at 74 characters with xy coords:* ``` 2sqrt(sum(rowSums(sapply(scan(,""),switch,u=0:1,d=0:-1,l=-1:0,r=1:0))^2)) ``` Usage: ``` > 2sqrt(sum(rowSums(sapply(scan(,""),switch,u=0:1,d=0:-1,l=-1:0,r=1:0))^2)) 1: u u u u d r r r l 10: Read 9 items [1] 7.211103 ``` Takes input as stdin, need to be lower-case and space-separated. Use x-y coordinates starting from (0,0). [Answer] # k (~~50~~ 49) ``` {2sqrt x$x:0 0f+/("udlr"!(1 0;-1 0;0 -1;0 1))@x} ``` Example ``` {2sqrt x$x:0 0f+/("udlr"!(1 0;-1 0;0 -1;0 1))@x}"uuuudrrrl" 7.211103 ``` [Answer] ## Java, 185, 203, 204, 217, 226 ``` class A{public static void main(String[] a){int x=0,y=0;for(int i=0;i<a[0].length();i++) switch(a[0].charAt(i)){case'U':y++;break;case'D':y--;break;case'L':x++;break;case'R':x--;}System.out.print(Math.hypot(x,y)2);}} ``` I did assume that each "U" was "1 up", so two units up would be "UU" Edit: swapped out switch for ifs ``` class A{public static void main(String[]a){int x=0,y=0;for(int i=0;i<a[0].length();i++){int c=a[0].charAt(i);if(c=='U')y++;if(c=='D')y--;if(c=='L')x++;if(c=='R')x--;}System.out.print(Math.hypot(x,y)2);}} ``` Moved for iterator ``` class A{public static void main(String[]a){int x=0,y=0;for(int i=0;i<a[0].length();){int c=a[0].charAt(i++);if(c=='U')y++;if(c=='D')y--;if(c=='L')x++;if(c=='R')x--;}System.out.print(Math.hypot(x,y)2);}} ``` No longer takes input as string, rather array of directions ``` class A{public static void main(String[]a){int x=0,y=0;for(String s:a){char c=s.charAt(0);if(c=='U')y++;if(c=='D')y--;if(c=='L')x++;if(c=='R')x--;}System.out.print(Math.hypot(x,y)2);}} ``` [Answer] # T-SQL, 158 ``` IF PATINDEX('%[^UDLR]%', @s)=0 select 2sqrt(power(LEN(REPLACE(@s,'U',''))-LEN(REPLACE(@s,'D','')),2)+power(LEN(REPLACE(@s,'L',''))-LEN(REPLACE(@s,'R','')),2)) ``` The @s is the input string of varchar(max) type [Answer] ## ES6, ~~77~~ 69 Definition: ``` f=s=>{u=d=l=r=0;for(c of s)eval(c+'++');return 2Math.hypot(u-d,l-r)} ``` Usage: ``` >>> f('uuuudrrrl') 7.211102550927979 >>> f( 'uuuudrrrl'.split('') ) 7.211102550927979 ``` * Accepts string OR array (lowercase) * Doesn't use imaginary numbers * Would not have been possible just 3 days before OP posted the question; that is, it only runs in Firefox 27+ (and maybe also Chrome with experimental stuff enabled, haven't tested :)!! (Inspired partially by Boann's answer.) [Answer] ## JavaScript - 142 characters - no eval() ``` function r(a){return Math.sqrt(Math.pow(a.match(/u/g).length-a.match(/d/g).length,2)+Math.pow(a.match(/l/g).length-a.match(/r/g).length,2))2} ``` where a is a string like 'uudrrl' use like this - ``` a='uudrrl' r(a) ``` Test in browser console. ``` var x = "luluurrrrurd" r(x) 8.48528137423857 ``` [Answer] # C# - 90 characters Fresh from LINQPad. ``` int x=0,y=0;input.Max(i=>i==85?y++:i==82?x++:i==68?y--:x--);(Math.Sqrt(xx+yy)2).Dump(); ``` Where input is a valid string. ``` >string input = "LULUURRRRURD"; >8.48528137423857 ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ 9 bytes ``` O:3 ıSḤA ``` [Try it online!](https://tio.run/##y0rNyan8/9/fyljhyEat4Ic7ljj@///fJ9QnNDQICEKDXAA "Jelly – Try It Online") I fiddled around with other functions to see if I could get rid of the space by finding a different one-byte dyad that would take a two-digit number on the left rather than the right, but it turned out that `:` doesn't need two digits to produce the desired values. ``` O Codepoints of the input :3 floor divided by 3. ı Raise sqrt(-1) to the power of each, S sum, Ḥ double, A and take the absolute value. ``` [Answer] ## J, 29 characters ``` +:+&.:/-/_2[\#/.~/:~'ruld'i. ``` Only works with lower case directions and any characters other than `r`, `u`, `l`, and `d` will cause it to give a wrong answer. Usage: ``` +:+&.:/-/_2[\#/.~/:~'ruld'i.'uuuudrrrl' 7.2111 ``` Explanation: `'ruld'i.'uuuudrrrl'` The dyadic form of `i.` finds the index of items from the right argument in the left argument. In this case: ``` 'ruld'i.'uuuudrrrl' 1 1 1 1 3 0 0 0 2 ``` `/:~` sorts this list into ascending order: ``` /:~'ruld'i.'uuuudrrrl' 0 0 0 1 1 1 1 2 3 ``` `#/.~` counts the number of occurrences of each number: ``` #/.~/:~'ruld'i.'uuuudrrrl' 3 4 1 1 ``` `_2[\` chops it into 2 rows: ``` _2[\#/.~/:~'ruld'i.'uuuudrrrl' 3 4 1 1 ``` `-/` subtracts the bottom from the top ``` -/_2[\#/.~/:~'ruld'i.'uuuudrrrl' 2 3 ``` `+&.:` borrows [a trick from another J answer I saw this morning](https://codegolf.stackexchange.com/a/20163/737), and squares the items, then sums them, then performs a square root. See [under `&.`](http://jsoftware.com/help/dictionary/d631.htm) documentation: ``` +&.:/-/_2[\#/.~/:~'ruld'i.'uuuudrrrl' 3.60555 ``` `+:` doubles the result: ``` +:+&.:/-/_2[\#/.~/:~'ruld'i.'uuuudrrrl' 7.2111 ``` [Answer] ### Matlab, 51 characters My Matlab submission, works only with captial letters. This was a fun one! The hardest part was converting the string into an array of complex numbers to be summed. Function:* ``` f=@(s)abs(sum(fix((s-76.5)/8.5)+((s-79)i/3).^-99)) ``` Usage:* ``` >> f=@(s)abs(sum(fix((s-76.5)/8.5)+((s-79)i/3).^-99)) >> f('UURDL') ans = 1 >> ``` [Answer] ## JavaScript, 89 ``` function f(a){U=D=L=R=0;for(d in a)eval(a[d]+'++');return 2Math.sqrt((U-=D)U+(L-=R)L)} ``` Example: ``` <script> document.write(f(['U', 'U', 'U', 'U', 'D', 'R', 'R', 'R', 'L'])); </script> >7.211102550927978 ``` [Answer] # C, 120 ``` float d(char p){int v=0,h=0;while(p){v+=p=='U'?1:p=='D'?-1:0,h+=p=='R'?1:p=='L'?-1:0,++p;}return 2sqrt(vv+hh);} ``` `d("LULUURRRRURD")` -> `8.485281` [Answer] # JavaScript (no ES6, no eval) - 131 ``` f=function(h){for(i=0,a=[0,,0,0,0];i<h.length;++i)++a[(h.charCodeAt(i)>>2)-25];x=a[0]-a[4];y=a[2]-a[3];return Math.sqrt(xx+yy)2} ``` Test: ``` console.log(f('uuuudrrrl')); // 7.211102550927978 console.log(f('luluurrrrurd')); // 8.48528137423857 ``` [Answer] # Javascript, 136 ``` function z(a){var x=a.split('u').length-a.split('d').length;var y=a.split('r').length-a.split('l').length;return Math.sqrt(xx+yy)2;}; ``` Example: ``` document.write(z('uuuudrrrwl')); 7.211102550927978 ``` [Answer] # [Perl 5](https://www.perl.org/) `-p`, 44 bytes ``` $_=2sqrt((y/R//-y/L//)2+(y/U//-y/D//)2) ``` [Try it online!](https://tio.run/##K0gtyjH9/18l3tZIq7iwqERDo1I/SF9ft1LfR19fU0vLSBsoEAoWcIEIaP7/7xPqExoaBAShQS7/8gtKMvPziv/rFgAA "Perl 5 – Try It Online") [Answer] # Befunge-93 (65) It has 65 non-whitespace characters (217 with whitespace, though that can be reduced by a more compact layout (for 69/176 chars)). It takes some liberality with the output format, but is undeniably accurate. Doesn't seem worth the effort to implement/steal a square root implementation. ``` v >$:\:+8845-2.,.@ >3-:\| >6-:\| >8-:\| >~"D"-:\| $ $ $ $ \ \ 1 1 1 1 - - + + \ \ ^ < < < < ``` `echo 'UUDLLUU' \| ./befungee.py ../man` outputs 2√13 (actually implementation seems to have issue with the extended ASCII though). ]
[Question] [ As some of you may know, to get a language onto Dennis's wonderful [Try It Online!](https://tio.run/#), a Hello, World! program is required. Recently, Dennis pushed up a way to load these programs from the website. Here is a JSON [pastebin](https://pastebin.com/jVifgcZ6) of the characters used in those programs, by frequency, as of July 27, 2017. Some of those characters need some love, so your challenge is to output Hello, World! (preferably in a language involved in this process), using only the characters specified below. These characters are all of the characters used between `10` and `99` (inclusive) times, along with the two most common characters, `0` and , because I'm feeling nice. ``` 0 $&?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_ ``` Your usage of the character should be based on its appearance in a normal program, not based on its code point or byte value. You must use at least one character from that set, so 0-length programs are invalid. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins. [JSFiddle to check if your answer is valid](http://jsfiddle.net/t4ujwm1s/2/embedded/result/) [Answer] # [Perl 5](https://www.perl.org/), 76 bytes ``` }{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\G ``` This uses a feature that has been deprecated, but works locally in my terminal (which is version 5.18.2 as noted). In older versions of Perl `?\w?` is a synonym for `/\w/` which gives me access to regexp matching and I have enough chars for `$&` (last match) and `$`` (text preceding last match). I need these to be able to get the `O`. I generate this be creating a `glob` reference (`$_=\G` which, cast to a scalar, is [something like `GLOB(0x7ffb728028d0)`](https://tio.run/##K0gtyjH9/7@gKDOvRCFGy/3/fwA "Perl 5 – Try It Online")). Once that's in `$_`, `?B?` will match the `B` and `$`` will contain `GLO`, I can then match against `\w$` which would store `O` in `$&` which is inserted into the strings that I'm running stringwise-AND to create the rest of the text, the body of the string is lowercased using `\L`. [Try it online!](https://tio.run/##K0gtyjH9/19ZobZapVol3lYlocLeyb622j6mXAVIAUUKC6t90mN8fHxU1GwVylXUgnxcbGvVCgttK2shoj4K8WBRR9taW6D6GC13LoRh@k76tdX6QMP0yTXs//9/@QUlmfl5xf91CwA "Perl 5 – Try It Online") - uses `/\w/` in place of `?\w?` as the version of Perl on TIO is too new. --- # [Perl 5](https://www.perl.org/), 65 bytes This is a bit more cheaty as it relies on the filename on TIO (which is `.code.tio`), so I don't really think this is competing, but I was happy with the result! ``` }{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=} ``` [Try it online!](https://tio.run/##K0gtyjH9/7@2WqVaJd5WxaC2Wj@mXEW/FsQrLKz2SY/x8fFRUbNVKFdRC/Jxsa1VKyy0rayFiPooxINFHW1r////l19QkpmfV/xftwAA "Perl 5 – Try It Online") [Answer] # [Unary](https://esolangs.org/wiki/Unary), 7\10182 bytes Unary is Brainfuck converted to binary converted to unary using `0` as the counter. Essentially, it condenses a Brainfuck program into a number and the output is that number of `0`s. They are usually very large programs. I won't paste the program here because I don't know how much text SE allows but I bet it's less than this. Instead, I'll paste the precise number of zeroes in this answer: ``` 708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556 ``` As this is a fairly cheap answer, guaranteed to not be the shortest, and I simply [copied](http://progopedia.com/example/hello-world/191/) it, I'm making this a wiki post. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), ~~137~~ ~~106~~ 95 bytes ``` X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g*B ``` [Try it online!](https://tio.run/##MzBNTDJM/f8/wsAAiFwiYAQQR4BFgCwwG4wioEQEGBhAaIgKkEoDIOkCEvVyBjLTQWwgpaWl5fT/PwA "05AB1E – Try It Online") -31 thanks to @Adnan for pointing out I could use base 108. -?? thanks to @Riley for pointing out some things wrong. --- Old version (different method): # [05AB1E](https://github.com/Adriandmen/05AB1E), ~~211~~ ~~186~~ 166 bytes ``` 0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000gB ``` [Try it online!](https://tio.run/##MzBNTDJM/f/fIN0AhKAgPTQCyoiAMNIhGEy5QAQUDGA60iNQKLAMkmnpCBoh5mKArAckkw6z2SvCAB2A7dXScvr/HwA "05AB1E – Try It Online") --- Haha! AND HERE I THOUGHT ESOLANGS STOOD NO PLAUSIBLE CHANCE! --- First we get 255 stored in X: ``` 00g # Push 2 (length of 00). 00000g # Push 5 (length of 00000). 00000g # Push 5. JU # Join to 255 and store in X. ``` Then, using the same length trick we push: `1296995323340359595058728869715` ``` 0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ ``` Where we just use `0<space>` instead of the length trick for the zeros. Then, finally, we push the 255 we stored and convert from 255 to base 10: ``` X # Push stored 255. B # Convert to base 255. ``` --- Still golfing using the other allowed chars, and duplication, it will be a minute. [Answer] # [Beatnik](https://esolangs.org/wiki/Beatnik), 148 bytes ``` K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA ``` [Try it online!](https://tio.run/##S0pNLMnLzP7/31shEALcFaJcFCIcFUACXkDKBc73dofyomBiYGEnZDUgE9wQCsACUJajQhRIJZANk3NC43sBVcA0OQFZ//8DAA "Beatnik – Try It Online") ## Explanation Beatnik bases the instruction executed based on the scrabble score of the word. Here's a shortened explanation: ``` Code Scrabble Score Explanation K 5 push the scrabble score of the next word QQQQQQQG 72 72 ['H'] ZD 12 pop a value; push it back twice XA 9 pop a value; print its ASCII character KD 7 pop two values; push their sum Z 10 pop two values; push their difference ``` [Answer] # Moorhens (v2.0), ~~3423~~ ~~983~~ ~~923~~ ~~866~~ ~~749~~ 716 bytes I think this can be golfed a bit, Moorhens is not an easy language to work with. ``` xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA ``` ## Explanation Moorhens is a language based of of dictionary words. Each word corresponds to an operation based on its hash. The five operations used here are `xU`, `ER`, `XI`, `KA`, and `AA` * `xU` increments the TOS * `ER` puts a new zero on the stack. * `XI` decrements the TOS * `KA` duplicates the TOS * `AA` rolls the TOS to the bottom We push each letter with sucessive applications of these operations. [Answer] # [SOGL V0.12](https://github.com/dzaima/SOGLOnline), ~~89~~ ~~75~~ 68 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md) ``` z{}xxxx≥x≥x≥xXUqXxq≤qq≤q R_IIRq q R_I0IIIRqxXq≤qxqxq CR_0II÷Rq0 ``` [Try it Here!](https://dzaima.github.io/SOGLOnline/?code=eiU3QiU3RHh4eHgldTIyNjV4JXUyMjY1eCV1MjI2NXhYVXFYeHEldTIyNjRxcSV1MjI2NHElMjAqUl9JSVJxJTIwJTIwcSUyMCpSX0kwSUkqSVJxeFhxJXUyMjY0cXhxeHElMjBDUl8wSUklRjdScTAq,v=0.12) Note: whenever `q` or output is referred to here, it doesn't pop as popping output (any of `oOpP`) are unavailable or output a prepending newline. Explanation (outdated, what's changed is that the "H" is printed using the alphabets letters): ``` $ push "$" R_ convert to an array of ordinals, then push all the contents to the stack 0II push 0+1+1 = 2 * multiply by that R convert to character q output z push the lowercase alphabet {} iterate over it, pushing each char, and do nothing. Stack: ["H","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"] stack manipulation: xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"] ≥ ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"] x ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"] ≥ ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"] x ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"] ≥ ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"] xxx ["l","o","r","H","a","b","c","d","e"] q output the "e" ≤ ["o","r","H","a","b","c","d","e","l"] qq output the "l" twice ≤ ["r","H","a","b","c","d","e","l","o"] q output the "o" * push "", R_ convert to an array of ordinals, then push all to stack II increase by 2 R convert back to character q output q push a space, then output push "" R_ convert to an array of ordinals, then push all to stack I increase that 0II push 0+1+1 = 2 multiply I increase Rq output as character stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"]) x ["r","H","a","b","c","d","e","l","o",","] X ["r","H","a","b","c","d","e","l","o"] q output the "o" ≤ ["H","a","b","c","d","e","l","o","r"] q output the "r" x ["H","a","b","c","d","e","l"] q output the "l" x ["H","a","b","c","d"] q output the "d" C push "C" R_ convert to ordinal as before 0II÷ floor divide by 2 Rq output as character 0* multiply by 0 so nothing extra would be outputted ``` Fun fact: all of the characters from the allowed characters are in SOGLs codepage :D [Answer] # [Glypho](https://web.archive.org/web/20060621185740/http://www4.ncsu.edu/~bcthomp2/glypho.txt), 480 bytes ``` AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB ``` [Try it online!](https://tio.run/##hVBbDoAwCDtb2WH0w0R/PT0KstgxiWHJCrS8lu081l0VkAYxE/jvfmBh3M38IsZaw1OtpGfOyB05Tsv9OY@OI94wzfU9C@9ONege766pR@Tyzr@zNhS1xluUdynmdsnj3M80FhPVCw "Glypho – Try It Online") [Answer] # Double JavaScript, 318 bytes I'm not sure if that's allowed, I couldn't do it using the JavaScript interpreter once. It's similar to use `eval()` but instead I'm using the interpreter twice: (Try it in the console to get the result printed back) ``` `\`\\x${0xA0xA&0xC}${0xA&0xC}\\x${0xA0xF&0xF}${0xB0xF&0xF}\\x${0xA0xF&0xF}C\\x${0xA0xF&0xF}C\\x${0xA0xF&0xF}F\\x${0xE0xF&0xF}C\\x${0xE0xF&0xF}${0}\\x${0xB0xF&0xF}${0xB0xB0xF&0xF}\\x${0xA0xF&0xF}F\\x${0xB0xB0xF&0xF}${0xE0xF&0xF}\\x${0xA0xF&0xF}C\\x${0xA0xF&0xF}${0xA0xA&0xC}\\x${0xE0xF&0xF}${00}\`` ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/V9h@z8hJiEmpkKl2qDCUQuI1QwqnGvBPDALScoNKOAGlnKC8zCknYkQcYOKuGKocUW2Bma4E4bdeOx3Q9KEqtGVFEejBgc212lpAR2YkPA/OT@vOD8nVS8nP12jQvM/AA "JavaScript (Node.js) – Try It Online") Evaluates to: ``` `\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21` ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/V9h@z8hpsLEIqbCzBSInaHYLabCCEgbGcRUmJpD@OZGUDkToLhhwv/k/Lzi/JxUvZz8dI0Kzf8A "JavaScript (Node.js) – Try It Online") Which evaluates to `Hello, World!` [Answer] # [Headsecks](https://esolangs.org/wiki/Headsecks), 78 bytes ``` yyzyzzxNxNzx{yyy{y{y{yzzz_{_zzyy\zxxxxxx\zzy\\zz\zx\{{\{{\zzz\xxx\{{\{{y\zzzx\ ``` [Answer] # [Smallf\\k](https://github.com/alexander-liao/smallf-k), 266 bytes: ``` zJ$NJ`ZZxgQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0TF j$?kCzQk}U}UgI$}Ew_yDL`qYIE_G}SCjXDFNJKGNIGyIwA\BzLP`zCILGCNqyYZyq? GwN{q{gKSj ``` Actually, the characters are kinda irrelevant. It's just a matter of whether or not each character has an even codepoint or an odd codepoint. Thus, I've made an effort to use every character available (except the multibyte characters) (though since it was randomised, I didn't make an effort to guarantee that). [Answer] # [Pyke](https://github.com/muddyfish/PYKE), ~~133~~ 144 bytes ``` ? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA ``` [Try it online!](https://tio.run/##TU07CoAwDL1Kj@ANpGootJ0eDkUCTi7topM49Ow1UQcTQsL7Zb/K1lpvhhSk8DSPxXfdUWtNlOdU3UpMHDkWnzELCgfS26gKYl5BbPj88wxxTIosGvWpZHmZAFqy4vYNEhOc0M9XWNvaDQ "Pyke – Try It Online") A horrible mess of code that can almost certainly be shortened... Constructs it one character at a time. ``` ? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point 00q}}}XEj - Construct 64 by doing `((0==0)222)2` and then eval, getting the "@" character and store it in `j` TX}G_E - Get "h" using `@` by looking it up in the alphabet \E\L\LkJ - "hELL" jRT}}XRGREkJ - "hELLo" jR 00q}R? B_RE - "," \ \wkJ - "hELLo, w" jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD" jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!" jRT}}RG_RE00q}}RAA - "Hello, World!" ``` [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 33 bytes ``` `gDKKN`\kPJkP` w`J`NQKCZ`kPJN ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgZ0RLS05gXFwqa1AqSmtQKmAgd2BKYE5RS0NaYGtQKkpOIiwiIiwiIl0=) As I've golfed this, it's become a lot more straightforward. For reference, the original looked something like [this](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrQXl5eWdgRUxMYE4wa0x5X0p5X3lfeV9HRF9EPURfSkRfVCtDYCB3YE5KSiRgUkxEYE5KSkpKRD1EX0pUQ0oiLCIiLCIiXQ==). For convenience, the string is constructed swapcase'd, then fixed at the end. This program makes heavy use of `kP` - `` in this context is ring translate, and `kP` printable ASCII, which is [arranged a bit weirdly](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrUCIsIiIsIiJd). ``` \kP* # The character `+`, made by ring translating `` `gDKKN` J # Append that to `gDKKN` kP # Ring translate again, producing `hELLO,` ` w`J # Append ` w` `NQKCZ`kP* # The string `NQKCD` ring translated to `ORLD!` # Don't ask why Z wraps to `!` JN # Append that and swap the case. ``` [Answer] # [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), ~~164~~ 162 bytes ``` zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAIPL?P ``` [Try it online!](https://tio.run/##S0n@/7@KEAhWAGJ7FBEVvBoCMEwox6Ui2AfIBvMCfFQCfBQCfMrhfJ8AR0@tAB/7gP//AQ "dc – Try It Online") There's likely a better/more interesting approach. I tried using the ASCII+256 trick that `dc` has, but that outputs additional characters as well (even if they're non-printing), and once I got to 'o', the wonderfully prime 111, I ran into trouble even getting a value of 111+(multiple of 256) that factored cleanly. So here's a fairly straightforward (albeit golfed where possible) solution: In `dc`, `z` is a command that pushes the stack depth onto the stack. That means we can use it as an increment. This is how I create most of my ASCII values for this challenge (printed with `P`), which I push onto named stacks with `S` and pop back onto the main stack with `L`. `dc` lets you use the hex values A-F even when the input radix is decimal (default). ~~Luckily, our first letter, 72, is a multiple of 12, so I save a byte or two here by multiplying 6\12 and printing immediately (`zzzzzzzCP`).~~ My 164-byte version used multiplication early on to get 72 ('H'), which was mildly clever but a holdover from an earlier attempt, and a waste of bytes. Now, I start by incrementing and saving the space, the exclamation point, and the comma, which are out of order, and therefore can't be printed yet. Next, I come to the 'H', which I print immediately, before I get to 'W', which I must save for later. I simply print when I hit the 'e', then I increment up to 'l'. I print two of those and save one. When I make it to 'o', I first thought I'd have to save one of those for later, but everything is kind of* in order at this point. I print an 'o', retrieve my comma, space, and 'W' from earlier, and now I'm right back to 'o'. I print this, and increment a few up to the highest necessary value, 'r' (114), which I print before loading and printing the 'l' I tucked away earlier. Almost done! 'd' is ASCII value 100, which is easily made by multiplying 10\*10 (fewer bytes than having stored it earlier and loading it now). Hex value `A` is 10, as is our input radix which we can retrieve with the command `I`. Multiply those, print, and then load and print our exclamation point from earlier. Hello, World! [Answer] # Deadfish~ ``` w ``` Honestly, the other answers are way more impressive. ]
[Question] [ Write a program or function that takes in a nonempty single-line string. The string will either be zero or more spaces followed by one period (a [particle](https://en.wikipedia.org/wiki/Wave)), such as `.` or `.`, *or* the string will be a sequence of one or more alternating forward and back slashes (a [wave](https://en.wikipedia.org/wiki/Particle)) that could start with either one, such as `\` or `/\/` or `\/\/\/\/\/\/`. In either case, propagate the [particle/wave](https://en.wikipedia.org/wiki/Wave%E2%80%93particle_duality) to the right by one unit. Specifically, in the particle case, insert a space before the `.`, moving it one place to the right, then output the resulting string. For example: `.` → `.` `.` → `.` `.` → `.` `.` → `.` `.` → `.` `.` → `.` `.` → `.` `.` → `.` In the wave case, append either `/` or `\` appropriately so the wave keeps alternating and it's length increases by one, then output the resulting string. For example: `/` → `/\` `\` → `\/` `/\` → `/\/` `\/` → `\/\` `/\/` → `/\/\` `\/\` → `\/\/` `/\/\` → `/\/\/` `\/\/` → `\/\/\` In either case, the output may not have trailing spaces but an optional trailing newline is allowed. The shortest code in bytes wins. [Answer] # C, 69 bytes ``` p;f(chars){p=s[strlen(s)-1]^46;p^=p?93:3022856;printf("%s%s",s,&p);} ``` This requires a little-endian machine, and output to a terminal that support ASCII escape codes. `p=s[strlen(s)-1]^46` grabs the last ASCII code of the input string, and XORs it with the ASCII code of a dot. `p^=p?93:3022856` will cause `p` to be `p^93` if the ASCII code is not a (back)slash, where `p^46^93 == p^115`, which will toggle between back and forward slash. If `p` is a dot, it will instead be `3022856`, which is little-endian for `"\b ."`. `printf("%s%s",s,&p);` prints the input string followed by the integer `p`, interpreted as a little-endian byte string. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~17~~ 14 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` ṪO2.ị“ .\/\”ṭ ``` [Try it online!](http://jelly.tryitonline.net/#code=4bmqTyoyLuG7i-KAnCAuXC9c4oCd4bmt&input=&args=L1wvXA) or [verify all test cases](http://jelly.tryitonline.net/#code=4bmqTyoyLuG7i-KAnCAuXC9c4oCd4bmtCuKAnC7igJwgLuKAnCAgLuKAnCAgIC7igJwgICAgLuKAnCAgICAgLuKAnCAgICAgIC7igJwgICAgICAgLuKAnC_igJxc4oCcL1zigJxcL-KAnC9cL-KAnFwvXOKAnC9cL1zigJxcL1wv4oCdw4figqxZ&input=). ### How it works ``` ṪO2.ị“ .\/\”ṭ Main link. Argument: s (string) Ṫ Tail; pop and yield the last character. O Ordinal; map “./\” to [46, 47, 92]. 2. Elevate the code point to the power 2.5. This maps [46, 47, 92] to [14351.41, 15144.14, 81183.84]. ị“ .\/\” Index into that string. Jelly's indexing is modular, so this takes the indices modulo 5, which gives [1.41, 4.14, 3.84]. Also, for a non-integer index, ị retrieves the elements at both adjacent integer indices (1-based). Here, these are [1, 2], [4, 5], and [3, 4], so we get " .", "/\", or "\/". ṭ Tack; append the characters to the popped input string. ``` [Answer] # CJam, 16 bytes ``` l)_'.={S\}"\/"?\| ``` [Try it online!](http://cjam.tryitonline.net/#code=bClfJy49e1NcfSJcLyI_fA&input=L1wvXA) or [verify all test cases](http://cjam.tryitonline.net/#code=cU4lewogICAgTClfJy49e1NcfSJcLyI_fApOfWZM&input=LgogLgogIC4KICAgLgogICAgLgogICAgIC4KICAgICAgLgogICAgICAgLgovClwKL1wKXC8KL1wvClwvXAovXC9cClwvXC8). ### How it works ``` l Read a line from STDIN. )_ Shift out the last character and copy it. '.= Compare the copy with a dot. ? If the last character is a dot: {S\} Push " " and swap the dot on top. "\/" Else, push "\/". \| Perform set union, ordering by first occurrence. " " '. \| -> " ." '/ "\/" \| -> "/\" '\ "\/" \| -> "\/" ``` [Answer] ## Python, 41 bytes ``` lambda s:[s+'\/'[s[-1]>'/'],' '+s][s<'/'] ``` Casework. Uses the sorted order `' ', '.', '/', '\'`. For spaces and period, prepends a space. Otherwise, appends a slash or blackslash opposite to the last character. [Answer] ## Python, ~~44~~ 42 bytes ``` lambda s:s[:-1]+"\/ /\."[-ord(s[-1])&3::3] ``` Replaces the last character with the correspond set of two characters. [ideone link](http://ideone.com/IPVvuI) (-2 bytes thanks to @xsot's shorter mapping function) [Answer] # Game Maker Language, 107 bytes ``` s=argument0;if string_pos(" ",s)return " "+s;if string_pos(s,string_length(s))="/"s+="\"else s+="/"return s ``` [Answer] # Vim, ~~27~~ 23 keystrokes First vim answer ever, haven't used vim at all really even. ``` A/<esc>:s#//#/\\<cr>:s#\./# .<cr> ``` How it works: It appends a `/` at the end of line, subs `//` for `/\`, subs `./` for `.` [Answer] # [MATL](https://github.com/lmendo/MATL), 19 bytes ``` t47<?0w}'\/'yO)o)]h ``` [Try it online!](http://matl.tryitonline.net/#code=dDQ3PD8wd30nXC8neU8pbyldaA&input=JyAuJw) Or [verify all test cases](http://matl.tryitonline.net/#code=YAp0NDc8PzB3fSdcLyd5TylvKV1oCkRU&input=Jy4nCicgLicKJyAgLicKJyAgIC4nCicgICAgLicKJyAgICAgLicKJyAgICAgIC4nCicgICAgICAgLicKJy8nCidcJwonL1wnCidcLycKJy9cLycKJ1wvXCcKJy9cL1wnCidcL1wvJw). ### Explanation ``` t % Input string implicitly. Duplicate 47< % Are entries less than 47 (i.e dot or spaces)? ? % If all are 0 % Push a 0. When converted to char it will be treated as a space w % Swap, so that when concatenated the space will be at the beginning } % Else '\/' % Push this string y % Duplicate the input string onto the top of the stack O) % Get its last element o % Convert to number ) % Use as (modular) index to extract the appropripate entry from '\/' ] % End h % Concatenate string with either leading 0 (converted to char) or % trailing '\' or '/'. Implicitly display ``` [Answer] # CJam, ~~35~~ ~~26~~ 25 bytes Saved 9 bytes thanks to dennis Saved 1 more byte, also thanks to dennis ``` q:I'.&SI+IW='/=I'\+I'/+?? ``` [Try it online!](http://cjam.tryitonline.net/#code=cTpJJy4jKVNJK0lXPScvPUknXCtJJy8rPz8&input=XC9c) Probably poorly golfed, but I'm not too familiar with CJam. There's probably a better way to check if an element is in an array, but I couldn't find any operators for that. Explanation: ``` q:I e# take input '.& e# push union of input and ".", effectively checking if input contains it SI+ e# push string with space in beginning IW='/= e# push 1 if the last chsaracter in the input is / I'\+ e# push the input with a \ appended I'/+ e# push the input with a / appended ? e# ternary if to select correct / ? e# ternary if to select final result ``` [Answer] ## 05AB1E, ~~17~~ 15 bytes ``` D'.åiðìë¤„\/s-J ``` Explanation ``` D'.åi # if input contains dot ðì # prepend a space ë # else ¤„\/s- # subtract last char of input from "\/" J # join remainder to input # implicitly print ``` [Try it online](http://05ab1e.tryitonline.net/#code=RCcuw6Vpw7DDrMOrwqTigJ5cL3MtSg&input=L1wv) [Answer] # C, 85 bytes ``` j;f(charn){j=strlen(n)-1;printf("%s%s",n[j]<47?" ":n,n[j]==46?n:n[j]==47?"\\":"/");} ``` [Ideone](https://ideone.com/1o1mPJ) I haven't slept for about 20 hours, my code probably can be golfed a lot. [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 35 bytes ``` t~m["\/.":X]t:"/\ "rm:?{.h" "\|r.}c. ``` [Test suite.](http://brachylog.tryitonline.net/#code=QG46MWF-QG53CnR-bVsiXC8uIjpYXXQ6Ii9cICJybTo_ey5oIiAifHIufWMu&input=Ii4KIC4KL1wvXC8KL1wvXApcL1wvXApcL1wvIg) (Slightly modified.) [Answer] ## Matlab, ~~74~~ ~~71~~ ~~62~~ 57 bytes ``` @(s)[s(1:end-1) ' .'+(s(1)>46)'/.'+(s(end)>47)[45 -45]] ``` It computes the last two characters based on the `s(1)` (first character) - to determine if we're dealing with the `\/` case, and the last character `s(end)` to make the correct tuple for the `\/` characters. [Answer] # Retina, 19 bytes ``` \. . /$ /\^H \\$ \/ ``` `^H` represents the BS byte. [Try it online!](http://retina.tryitonline.net/#code=XC4KIC4KLyQKL1wIClxcJApcLw&input=L1wv) [Answer] # [><>](https://esolangs.org/wiki/Fish), 47 bytes ``` i:0(?\ =?$r\~:1[:"./ \/"{=?@r=?$r~~]:48 l?!;o> ``` [Try it online!](http://fish.tryitonline.net/#code=aTowKD9cCio9PyRyXH46MVs6Ii4vIFwvIns9P0ByPT8kcn5-XTo0OApsPyE7bz4&input=L1w) The first line is a standard ><> input loop. The second line chooses the appropriate character from `/ \` to append to the string, based on the last input character. In addition, if the last input character was a `.`, the top two elements are switched. Finally, the stack contents are printed in reverse. [Answer] # JavaScript, ~~79~~ ~~70~~ ~~65~~ 58 bytes ``` (a,b="/\\/",i=b.indexOf(a[a.length-1]))=>i<0?" "+a:a+b[i+1] ``` [Answer] ## C# - 46 bytes `s=>s[0]<47?' '+s:s+(s.EndsWith("/")?'\\':'/')` [Try it here.](https://dotnetfiddle.net/4pWZH3) [Answer] # Haskell, ~~46~~ ~~45~~ 44 bytes ``` f z@(x:_)\|x<'/'=' ':z\|x<'0'='\\':z\|1<2='/':z ``` Takes advantage of the fact that < `.` < `/` < `0` < `\` in the ASCII table to save two bytes [Answer] ## Python 2, 72 bytes ``` lambda x:x[:-1]+(" .","\/","/\\")[ord(x[-1])/46+(-1,1)[ord(x[-1])%46>0]] ``` Any help golfing more would be greatly appreciated! This takes the last character in the input and converts it into its ASCII code to get the corresponding index in the list of two characters. Those two characters are appended to all the characters of the input up until the last one. [Answer] # SQF, 91 Using the function-as-a-file format: ``` s=_this;switch(s select[(count s)-1])do{case".":{" "+s};case"\":{s+"/"};case"/":{s+"\"};} ``` Call as `"STRING" call NAME_OF_COMPILED_FUNCTION` [Answer] ## Perl, 30 + 1 (`-p`) = 31 bytes ``` s/\./ ./,s\|/$\|/\\\|\|\|s\|\\$\|\\/\| ``` Needs `-p` and `-M5.010` or `-E` to run : ``` perl -pE 's/\./ ./,s\|/$\|/\\\|\|\|s\|\\$\|\\/\|' <<< ". . . / /\/" ``` Straight forward implementation of the challenge. (Note that the `\|\|` between the last two regex are `or`, as it might be hard to read, so the three regex are : `s/\./ ./`, and `s\|/$\|/\\\|`, and `s\|\\$\|\\/\|`) [Answer] ## C#, 54 bytes ``` s=>s.EndsWith(".")?" "+s:s+(s.EndsWith("/")?"\\":"/"); ``` [Answer] ## PowerShell v2+, ~~59~~ ~~58~~ ~~52~~ 51 bytes ``` param($n)(" $n","$n/","$n\")['.\/'.IndexOf($n[-1])] ``` Takes input `$n`, dumps it an array index operation. We select the element of the array based on the index `['.\/'.IndexOf($n[-1])` -- i.e., based on the last character of the input `$n`, this will result in `0`, `1`, or `2`. That corresponds to the appropriate string of the array. In any case, the resulting string is left on the pipeline and printing is implicit. ### Test cases ``` PS C:\Tools\Scripts\golfing> 0..7\|%{' '$_+'.'}\|%{"$_ => "+(.\wave-particle-duality.ps1 "$_")} . => . . => . . => . . => . . => . . => . . => . . => . PS C:\Tools\Scripts\golfing> '/,\,/\,\/,/\/,\/\,/\/\,\/\/'-split','\|%{"$_ => "+(.\wave-particle-duality.ps1 "$_")} / => /\ \ => \/ /\ => /\/ \/ => \/\ /\/ => /\/\ \/\ => \/\/ /\/\ => /\/\/ \/\/ => \/\/\ ``` [Answer] ## C#, ~~80~~ 63 bytes ``` s=>{var c=s[s.Length-1];retu‌rn c<'/'?" "+s:c>'/'?s+"/":s+"\\‌";} ``` [Answer] # ARM machine code on Linux, 50 bytes Hex dump: ``` b580 1e41 f811 2f01 2a00 d1fb 3901 780b 1a0a 4601 2001 2704 df00 2000 a103 2202 f013 0303 2b03 4159 df00 bd80 2e202f5c 5c2f ``` First post here, hope I'm doing this right. This is 32-bit ARM assembly, specifically Thumb-2. The input string is a NUL-terminated string taken in through r0, the output is printed to the stdout. In C-syntax, the prototype for the function would be void func\_name(char\ string). It is AAPCS (ARM calling convention) complaint, if it weren't then 2 bytes could be shaved off. Here's the equivalent assembly, with comments explaining what's happening: ``` @Input: r0 is char* (the string) @Output: Modified string to console push {r7,lr} @Save r7 and the link register subs r1,r0,#1 @Make a copy of the char, subtracting because we're @going to pre-increment. loop: @This loop is a little strlen routine ldrb r2,[r1,#1]! @In C-syntax, r2=++r1; cmp r2,#0 bne loop @Now r1 points to the null character that terminates the string subs r1,r1,#1 @Make r1 point to the last character ldrb r3,[r1] @Load the last character into r3 subs r2,r1,r0 @r2=length(r0) - 1; mov r1,r0 @r0 holds the original char* movs r0,#1 @1 is the file descriptor for stdout movs r7,#4 @4 is write swi #0 @Now all the characters from the initial string have been printed, @except for the last one, which is currently in r3. movs r0,#1 @1 is stdout, have to reload this since the system call @returns in r0. adr r1,msg @Load msg into r1 (the pointer to the string) movs r2,#2 @We're going to print two more characters. @Now the bit magic. The ascii codes for '\', '.', and '/' map onto @0, 2, and 3 when bitwise anded with 3 (0b11). @This will be the offset into our string. However, since we must print @2 characters, we need our offsets to be 0, 2, and 4. @Therefore, we only set the carry if our value is >=3, then add with @carry (adcs). Thus we get the correct offset into the string msg. ands r3,r3,#3 cmp r3,#3 @Sets carry if r3>=3 adcs r1,r1,r3 @Add the offset to r1 swi #0 @Make the system call pop {r7,pc} @Return and restore r7 msg: .ascii "\\/ ./\\" @The three different sequences of 2 characters that @can go at the end. ``` [Answer] # ECMAScript 6 / 2015 (JavaScript), 41 bytes ``` s=>s<'/'?' '+s:s+'\\/'[s.slice(-1)>'/'\|0] ``` Good catch Neil. [Answer] # R, 119 bytes ``` a=scan(,"");if((q=strsplit(a,"")[[1]][nchar(a)])=="."){cat(" ",a,sep="")}else{s=switch(q,"/"="\\","/");cat(a,s,sep="")} ``` Ungolfed : ``` a=scan(,"") if((q=strsplit(a,"")[[1]][nchar(a)])==".") cat(" ",a,sep="") else s=switch(q,"/"="\\","/") cat(a,s,sep="") ``` [Answer] # SED, 41 36 27 saved 7 thanks to charlie ``` s\|\.\| .\|;s\|/$\|/\\\|;t;s\|$\|/\| ``` uses 3 substitutions: `s/\./ ./` adds a space if there is a `.` `s\|/$\|/\\\|`,`s\|$\|/\|` adds the appropriate slash to the end uses `\|` instead of `/` as the delimiter `t` branches to the end if the second regex matches so it doesn't add the other slash [Answer] # [Turtlèd](https://github.com/Destructible-Watermelon/turtl-d/), 32 bytes (noncompeting) ``` l!-[+.r_]l(/r'\r)(\r'/)(." .")$ ``` Explanation: ``` [implicit] first cell is an asterisk l move left, off the asterisk, so the '[+.r_]' loop runs ! take input into string var, char pointer=0, 1st char - decrement char pointer, mod length input [* ] while current cell isn't : +. increment string pointer, and write the pointed char r_ move right, write if pointed char is last char, else " " l move left (/ ) if the current cell is / r'\r move right, write /, move right (\ ) If the current cell is \ r'/ move right, write / (. ) If the current cell is . " ." Write " .", the first space overwriting the existing '.' $ Program won't remove leading spaces when printing [implicit] Program prints grid after finishing execution ``` [Answer] # Java 7, 76 bytes ``` String c(String i){return i.contains(".")?" "+i:i+(i.endsWith("/")?92:'/');} ``` Pretty straightforward. Ungolfed & test code: [Try it here.](https://ideone.com/XAgEEC) ``` class M{ static String c(String i){ return i.contains(".") ? " " + i : i + (i.endsWith("/") ? 92 : '/'); } public static void main(String[] a){ System.out.println(c(" .")); System.out.println(c(" .")); System.out.println(c(" .")); System.out.println(c(" .")); System.out.println(c(" .")); System.out.println(c(" .")); System.out.println(c(" .")); System.out.println(c(" .")); System.out.println(c("/")); System.out.println(c("\\")); System.out.println(c("/\\")); System.out.println(c("\\/")); System.out.println(c("/\\/")); System.out.println(c("\\/\\")); System.out.println(c("/\\/\\")); System.out.println(c("\\/\\/")); } } ``` Output: ``` . . . . . . . . /\ \/ /\/ \/\ /\/\ \/\/ /\/\/ \/\/\ ``` ]
[Question] [ ### Introduction Let's take the number `180`. This is an interesting number because the sum of digits of this number is equal to: ``` 1 + 8 + 0 = 9 ``` And the squared version of this number, or: ``` 180² = 32400 > 3 + 2 + 4 + 0 + 0 = 9 ``` These are both 9. The sum of digits of the original number and the squared number are the same. Of course, this is also found at OEIS: [A058369](https://oeis.org/search?q=1%2C+9%2C+10%2C+18%2C+19%2C+45+%2C46%2C+55%2C+90%2C+99%2C+100&language=english&go=Search). ### Task Given a non-negative integer `n`, output the `n`th positive number with this condition. ### Test cases (zero-indexed) ``` Input > Output 0 > 1 1 > 9 2 > 10 3 > 18 4 > 19 5 > 45 6 > 46 7 > 55 8 > 90 9 > 99 10 > 100 11 > 145 12 > 180 13 > 189 14 > 190 15 > 198 16 > 199 17 > 289 18 > 351 19 > 361 ``` The input can also be 1-indexed if that fits you better. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the submission with the least amount of bytes wins! [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~10~~ ~~9~~ 8 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` µNÐn‚1öË ``` 1-indexed. -1 byte thanks to @Emigna by removing the implicit `½` (increase `counter_variable` after every iteration) at the end -1 byte thanks to @Grimy removing the duplicated `SO` by using `‚1ö` [Try it online.](https://tio.run/##yy9OTMpM/f//0Fa/wxPyHjXMMjy87XD3///mAA) Explanation: ``` µ # Loop while the counter_variable is not equal to the (implicit) input yet: NÐ # Push the 0-based loop index three times n # Take the square of this index # i.e. 180 → 32400 ‚ # Pair it with the index # i.e. 180 and 32400 → [180,32400] 1ö # Convert both numbers from base-1 to base-10, which basically sums the digits # i.e. [180,32400] → [9,9] Ë # Check if both sums are equal # i.e. [9,9] → 1 (truthy) # (if they are: implicitly increase the counter_variable by 1) # (after the loop: implicitly print the top of the stack, which is the remaining # copy of the index from the triplicate we've used) ``` [Answer] # Jelly, 13 bytes ``` ,²DS€=/ 1Ç³#Ṫ ``` Input is 1-indexed. [Try it online!](http://jelly.tryitonline.net/#code=LMKyRFPigqw9Lwoxw4fCsyPhuao&input=&args=MTk) ### How it works ``` 1Ç³#Ṫ Main link. Argument: n (index) 1 Set the return value to 1. # Execute ... until ... matches have been found. Ç the helper link ³ n Ṫ Extract the last match. ,²DS€=/ Helper link. Argument: k (integer) ,² Pair k with k². D Convert each to decimal. S€ Compute the sum of each list of base 10 digits. =/ Reduce by equality. ``` [Answer] # Mathematica, 64 bytes ``` a=Tr@IntegerDigits;Nest[NestWhile[#+1&,#+1,a@#!=a[#^2]&]&,1,#]& ``` Simple anonymous function. Zero-indexed. [Answer] ## Haskell, 54 bytes ``` s=sum.map(read.pure).show ([x\|x<-[1..],s x==s(x^2)]!!) ``` Usage example: `([x\|x<-[1..],s x==s(x^2)]!!) 17` -> `289`. ``` s calculates the digit sum: show -- turn number into a string map(read.pure) -- turn every character (the digits) in to a -- one element string and convert back to integer sum -- sum those integers main function: [x\|x<-[1..] ] -- make a list of all x starting from 1 ,s x==s(x^2) -- where s x == s (x^2) !! -- pick nth element from that list ``` [Answer] # Perl 6, ~~47~~ 46 bytes ``` {(grep {$_.comb.sum==$_².comb.sum},1..)[$_]} ``` [Answer] # Pyth, 15 ``` e.fqsjZTsj^Z2TQ ``` 1 byte thanks to DenkerAffe! [Try it here](https://pyth.herokuapp.com/?code=e.fqsjZTsj%5EZ2TQ&input=13&debug=0) or run a [Test Suite](https://pyth.herokuapp.com/?code=e.fqsjZTsj%5EZ2TQ&input=0&test_suite=1&test_suite_input=1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A9%0A10%0A11%0A12%0A13%0A14%0A15%0A16%0A17%0A18%0A19%0A20&debug=0). Uses the 1-indexed option. Naive implementation using `.f` which gets the first `n` numbers that match the given condition. [Answer] # JavaScript (ES6), ~~76 73~~ 72 bytes ``` n=>eval("for(q=s=>eval([...s+''].join`+`),i=1;q(i)!=q(ii)\|\|n--;i++);i") ``` I spent 30 minutes trying to get this to work until I realized I was outputting the wrong variable :\| This is zero-indexed. [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 8 bytes ``` ↵'²"Ṡ≈;i ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLihrUnwrJcIuG5oOKJiDtpIiwiIiwiMSJd) Insights scraped from the [MathGolf answer](https://codegolf.stackexchange.com/a/185357/107299) and the [05AB1E answer](https://codegolf.stackexchange.com/a/164398/107299). ``` ↵'²"Ṡ≈;i # Takes the number as input and returns the n-th number in the series, 0-indexed ↵ # 10input ' ; # Filter the implicit range [0..n] ² # Square the input " # Pair the square with the input Ṡ # Vectorised sum ≈ # All equal? i # Index into the resulting list ``` [Answer] # [MATL](https://esolangs.org/wiki/MATL), ~~24~~ 23 bytes ``` x`@2:^"@V!Us]=?@]NG<]1$ ``` Uses 1-based input. [Try it online!](http://matl.tryitonline.net/#code=eGBAMjpeIkBWIVVzXT0_QF1ORzxdMSQ&input=MTI) ``` x % take inpout and delete it (gets copied into clipboard G) ` % do...while @ % push loop iteration index: candidate number, n 2:^ % array [n n^2] " % for each element of that array @ % push that element V!U % get its digits (to string, transpose, to number) Xs % compute their sum ] % end for each = % are the two sums equal? ? % if so @ % the candidate number is valid: push it ] % end if NG< % is number of elements in stack less than input? ] % if so, proceed with next iteration. End do...while. 1$ % specify 1 input for implicit display: only top of stack ``` [Answer] # PARI/GP 46 bytes ``` s=sumdigits;k=0;while(n,n-=!(s(k++)-s(k^2)));k ``` 1-indexed [Answer] # Julia, ~~79~~ 66 bytes ``` f(n,x=0,i=1,s=c->sum(digits(c)))=x<n?f(n,x+(s(i)==s(i^2)),i+1):i-1 ``` This is a recursive function that accepts an integer and returns an integer. It uses 1-based indexing. We store a few things as function arguments: `n` : The input * `x` : A counter for how many numbers with this condition we've found * `i` : A number to check for the condition * `s` : A function to compute the sum of the digits of its input While `x` is less than the input, we recurse, incrementing `x` if `i` meets the condition and incrementing `i`. Once `x == n`, we return `i`, but we have to subtract 1 because it will have been incremented one too many times. [Answer] ## Convex 0.2, ~~36~~ 35 bytes Convex is a new language that I am developing that is heavily based on CJam and Golfscript. The interpreter and IDE can be found [here](https://github.com/GamrCorps/Convex). Input is an integer into the command line arguments. Indexes are one-based. Uses the CP-1252 encoding. ``` 1\{\__2#¶{s:~:+}%:={\}{)\}?}h;( ``` [Answer] # Mathematica, ~~63~~ ~~60~~ ~~61~~ 59 bytes ``` Select[Range[9^#],Equal@@Tr/@IntegerDigits/@{#,#^2}&][[#]]& ``` ~~While making this the other answer popped up but I'm beating them by a single byte and I'm posting this before that one gets golfed.~~ One indexed. [Answer] # Retina, 103 bytes ``` \d+ $1 x {`x+ $.0$x¶$.0$a¶$.0$b %`b $_ a+\|b+ $.0 \d $* +`1¶1 ¶ 1(.)¶¶$\|¶[^d]+ $1x }`^ ?x x ``` Definitely golfable. Uses the [new Retina feature `%`](http://chat.stackexchange.com/transcript/message/28044230#28044230) for squaring (hence not working with the online version yet). [Answer] # Mathcad, ~~70~~ 50 bytes Mathcad has no built in functions to convert a number to its digit string, so the user function d(a) does this job. A program then iterates through the positive integers, testing for equality of sums, until it has accumulated n numbers in the vector v. The program is evaluated using the = operator, which displays the result vector. (Note that the whole program appears exactly as displayed below on the Mathcad worksheet) Updated program: Assumes default initialization of a to zero and makes use of fact that Mathcad returns the value of the last evaluated statement in a program. Makes use of evaluation order of expressions to increment variable a in the first summation (and which is then available for use in the sum of square) [![enter image description here](https://i.stack.imgur.com/iMWfW.jpg)](https://i.stack.imgur.com/iMWfW.jpg) Original program: Returns a vector of all numbers up to n. [![enter image description here](https://i.stack.imgur.com/Bp0VD.jpg)](https://i.stack.imgur.com/Bp0VD.jpg) [Answer] # [Ruby](https://www.ruby-lang.org/), 85 bytes ``` ->n,a{[(1..).lazy.filter_map{_1 if _1.digits.sum==(_12).digits.sum}.take(n)][-1]} ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuhY3Q3Xt8nS0EqujtTQM9fQ09XISqyr10jJzSlKL4nMTC6rjDRUy0xTiDfVSMtMzS4r1iktzbW014g21tIw0kcRq9UoSs1M18jRjo3UNY2uhhpuAzDQy0NRLTUzOUEjJ51JQKCgtKVZQUjVKUdC1U1BNUVJQVYiON9RRcAOSsbFcqXkpEL0LFkBoAA) [Answer] # [Fig](https://github.com/Seggan/Fig), \$10\log\_{256}(96)\approx\$ 8.231 bytes ``` iFmN'=SxS ``` [Try it online!](https://fig.fly.dev/#WyJpRm1OJz1TeFMqIiwiOCJd) Could be ~7.4 bytes under normal sequence rules ## Explained ``` iFmN'=SxS* FmN' # From an infinite list of natural numbers, keep only those where Sx # the digital sum of the number = # equals S* # the digital sum of the square of the number i # get the inputh item of the list ``` [Answer] # [Pip](https://github.com/dloscutoff/pip), ~~22~~ ~~21~~ 20 bytes ``` ($=$+[_SQ_]FI,EE3a) ``` -2 Bytes thanks to [DLosc](https://codegolf.stackexchange.com/users/16766/dlosc)! 1-Indexed Currently operates with a limited range for efficiency, replace `3` with `a` for infinite range [Try It Online!](https://dso.surge.sh/#@WyJwaXAiLCIiLCIoJD0kKypbX1NRX11GSSxFRTNhKSIsIiIsIiIsIjIwIl0=) How? ``` ($=$+[_SQ_]FI,EE3a) EE3 - 10 to the power of 3 , - Range 0 to n FI - Filter: keep items which return truthy [ ] - Pair _ - Identity function SQ_ - Identity function squared $+* - Sum, vectorized at a depth of 1 $= - Are they equivalent? a - Value at index Input ``` [Answer] # Java 8, 113 bytes ``` n->{int r=0;for(;n>=0;)if((++r+"").chars().map(c->c-48).sum()==(rr+"").chars().map(c->c-48).sum())n--;return r;} ``` 0-indexed Explanation:* [Try it online.](https://tio.run/##hY9LTsMwEIb3nGKU1QyWLYRYIExyA7rpsrAwbkJdkkk0dipVVc4e7LZ7pHk/pO8/upPTx/3v6nsXI3y4wJcHgMCplc75FjalvQ7AY4lMNk@W7Nlicil42ABDDSvr5lJOpH6y3ShouckVhQ5RKVFVRcYfnEQkM7gJvW68fnklE@cBqa5RHv87ItbaSptmYRC7rPaGMc3ffca405zGsIchK8FtksA/uy9HNxUFqgCGjAXhvX4uSSm6LgG255jawYxzMlN@TD1jUNXbZ6oUm6ye7tKX9Q8) ``` n->{ // Method with integer as both parameter and return-type int r=0; // Result-integer, starting at 0 for(;n>=0;) // Loop as long as `n` is zero or positive if((++r // Increase `r` by 1 first +"").chars().map(c->c-48).sum() // And if the sum of its digits ==(rr+"").chars().map(c->c-48).sum()) // equals the sum of the digit of its square n--; // Decrease `n` by 1 return r;} // Return the result ``` [Answer] # [Perl 5](https://www.perl.org/) `-p`, 53 bytes Includes `+1` for `-p` 1 based ``` #!/usr/bin/perl -p $.++while$_-=!eval+("-($.) ".$.2)=~s/\B/+/gr;$_=$. ``` [Try it online!](https://tio.run/##K0gtyjH9/19FT1u7PCMzJ1UlXtdWMbUsMUdbQ0lXQ0VPU0FJT0VPS8tI07auWD/GSV9bP73IWiXeVkXv/3/Tf/kFJZn5ecX/dQv@6/qa6hka6BkAAA "Perl 5 – Try It Online") [Answer] # TI-BASIC ~~66~~ 62 bytes ``` Ans→N:While X<N:IS>(A,A::A:prgmA:Ans→B:A²:prgmA:If B=Ans:IS>(X,N:End:A sum(int(10fPart(Ans₁₀^(seq(⁻X-1,X,0,log(Ans ``` Input is \$n\$ in `Ans`. Output is the 1-indexed* \$n\$th term in the sequence. Helper function generates the sum of the digits of the value in `Ans`. Examples: ``` 3:prgmCDGF1E 10 5:prgmCDGF1E 19 8:prgmCDGF1E 55 10:prgmCDGF1E 99 ``` Explanation: ``` Ans→N:While X<N:IS>(A,A::A:prgmA:Ans→B:A²:prgmA:If B=Ans:IS>(X,N:End:A ;prgmCDGF1E Ans→N ;store the input in N While X<N ;loop until the Nth term has been reached IS>(A,A: ;add 1 to A ; (Increment A and skip the next statement if A>A) A ;leave A in Ans prgmA ;call the helper program below Ans→B ;store the result of the helper program in B A² ;square A and leave the result in Ans prgmA ;call the helper program below ; (result is in Ans) If B=Ans ;if the two results are equal IS>(X,N ;add 1 to X ; (Increment X and skip the next statement if X>N) End A ;leave A in Ans ;implicit print of Ans sum(int(10fPart(Ans₁₀^(seq(⁻X-1,X,0,log(Ans ;prgmA seq(⁻X-1,X,0,log(Ans ;generate a list... ; using X as the variable, ; starting at 0, ; ending at the log of Ans, ; and evaluating "⁻X-1" for each element ; (implicit increment of 1) ₁₀^( ;raise 10 to the power of each element Ans ;multiply each element by the input fPart( ;remove the integer part from each element 10 ;multiply each element by 10 int( ;round each element to the nearest integer sum( ;then sum the resulting list ``` --- Note: TI-BASIC is a tokenized language. Character count does *not* equal byte count. [Answer] # [J](http://jsoftware.com/), 62 bytes ``` [:{:({.@](>:@[,],[#~(=&(1#."."0@":):)@[)}.@])^:(#@]<1+[)^:_&1 ``` [Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o62qrTSq9RxiNeysHKJ1YnWiles0bNU0DJX1lPSUDByUrDS1rDQdojVrgWo046w0lB1ibQy1o4HMeDXD/5pcqckZ@QoaaUoGmgqG2pl6Rgb/AQ "J – Try It Online") 1 indexed. J once again not performing well on these "nth of" tasks, because of the excessive bookeeping mechanics. [Answer] # APL(NARS), 49 chars, 98 bytes ``` r←h w;c c←r←0 →2×⍳∼=/+/¨(⍎¨⍕)¨r,r×r+←1⋄→2×⍳w>c+←1 ``` 1-indexed, test: ``` h¨⍳20 1 9 10 18 19 45 46 55 90 99 100 145 180 189 190 198 199 289 351 361 ``` [Answer] # [MathGolf](https://github.com/maxbergmark/mathgolf), 10 bytes ``` ♪╒gÆ‼Σ²Σ=§ ``` [Try it online!](https://tio.run/##DcghEkBAAIbR/p3Gb1krOIyCwCgOIDmAGUEWzIiyRHeIvcjy4uvKoan7tgrBr4df5vqZ/Hi9232@W3HvIUSIGENCiiXDkaM/hWJkUIJSZFGGHMo/ "MathGolf – Try It Online") ## Explanation To make this usable, I chose to present a version which calculates every number with this property below 1000, and fetches the correct item from that list. To have a solution which would work for any input size, the first byte could be replaced by `ú` (push 10\\TOS). Since the n:th term in the sequence is always less than \$10^n\$, the script would always succeed. However, this puts a practical limit on calculation that's very low. ``` ♪ push 1000 ╒ range(1,n+1) gÆ filter list using the next 5 operators ‼ apply next two commands to TOS Σ sum(list), digit sum(int) ² pop a : push(aa) (square) Σ sum(list), digit sum(int) (pushes the digit sum of the square) = pop(a, b), push(a==b) (compares the two) § get from array (returns the <input>th item from the filtered list ``` [Answer] # JavaScript, ~~67~~ 66 bytes I feel very rusty golfing in JS so I'm sure there's something I'm missing here. 1-indexed ``` n=>(g=x=>(h=y=>eval([...y+``].join`+`))(++x)-h(xx)\|\|--n?g(x):x)`` ``` [Try it online!](https://tio.run/##DcRLCoMwEADQq7joYqZDArqsjT1El6UwQeMPSSQGGak9e9q3eLPd7dbGaU3Kh87l3mRvGhiM/B/NYRq32wVeWuuDmN96DpNnYkQgElQjyFXwPJXyjwEEb4LMuQ8RxJS13Kuyxjb4LSxOL2EAvnzky3q13TPZmKBC4kI1BVMPQoSYfw) [Answer] # [Python 3](https://docs.python.org/3/), ~~125~~ 124 bytes ``` def f(x,i=1,a=()): while len(a)!=x: if sum(int(j)for j in str(i))==sum(int(j)for j in str(i2)):a+=i, i+=1 print(i-1) ``` [Try it online!](https://tio.run/##dYxBCsIwEEX3OcV3N9NGMIobYQ4TMEOn1LSkEevpY3sAt@893vKtw5xvrT2TQmnzJsFHIeaHw2ewKWFKmSKfZNsJTLG@X2S50sg6F4ywjLUWMmaRf67rrvsx9mL@mPQSHJZylHYO3JTu7JTChdsP "Python 3 – Try It Online") 1-indexed [Answer] # [Japt](https://github.com/ETHproductions/japt), ~~15~~ 12 bytes 1-indexed ``` Èìx ¶X²ìx}iU ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=yOx4ILZYsux4fWlV&input=NQ) ``` Èìx ¶X²ìx}iU :Implicit input of integer U È :Function taking an integer as argument X ì : To digit array x : Reduce by addition ¶ : Is equal to X²ìx : Digit sum of X squared } :End function iU :Get the Uth integer that returns true ``` [Answer] # [Factor](https://factorcode.org/) + `benchmark.ant lists.lazy`, 56 bytes ``` [ 1 lfrom [ dup sq [ sum-digits ] same? ] lfilter lnth ] ``` [Try it online!](https://tio.run/##JcwxDsIwEAXRPqf4FyCSWygoEQ0NoopSbBybWFk7Zr0pwuWNJap51Xiyukl9Pe@P2xkcipae6Xv8idVJcoxIumByyS6RZO0pKbI41SNLaL50nTF1gAF72SIGzHtG@TSUPZ7m8A7tNaJQdNdW9oHVCTi17VgtMaOvPw "Factor – Try It Online") `1 lfrom` Infinite lazy list of the positive integers * `[ ... ] lfilter` Take the ones where... * `dup sq [ sum-digits ] same?` ...the digit sum of the number and its square are the same * `lnth` Take the nth one [Answer] # JavaScript, 60 bytes ``` n=>(g=x=>(s=x=>x&&x%10+s(x/10\|0))(++x)-s(xx)\|\|n--?g(x):x)`` ``` An alternate approach for the sum of digits. 0-indexed. [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~66~~ 65 bytes -1 bytes thanks to [@ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat) ``` i;s(n){n=n?n%10+s(n/10):0;}f(n){for(i=0;n-=s(++i)==s(ii););n=i;} ``` [Try it online!](https://tio.run/##JYvBCsJADETv/YpQKGzcFrceG4M/4qVs2RLQKK3goeyvu6Y6l8nMvMRujrEUodUpbsp60aYP3tKxDzgEymkf0mNxwoG049V5L8jmchAkJGWhXERfcB9FHUK1VWCyH3B7LcDQk9mZ4RTs8B5/xJ/b9VwMTK5upgGa6ap1C9JCcoJIPyhXuXxiuo3zWrr3Fw "C (gcc) – Try It Online") ]
[Question] [ Consider the sequence \$(a\_n)\$ defined in the following way. * \$a\_0=0\$ * For all \$n=1, 2, 3, \dots\$, define \$a\_n\$ to be the smallest positive integer such that \$a\_n-a\_i\$ is not a square number, for any \$0\leq i<n\$ In other words, this is the lexicographically first sequence where no two terms differ by a square. It is proven that this sequence is infinite, and it is [A030193 in the OEIS](https://oeis.org/A030193). The sequence begins `0, 2, 5, 7, 10, 12, 15, 17, 20, 22, 34, 39, 44, 52, 57, 62, 65, 67, 72, 85, 95, 109, 119, 124, 127, 130, 132, 137, 142, 147, 150, 170, 177, 180, 182, 187, 192, 197, 204, 210, 215, 238, 243, 249, 255, 257, 260, 262, 267,...` ## Challenge The challenge is to write a program or function which does one of these: * Takes a nonnegative integer `n` and returns or prints the n-th term of this sequence. Either 1-indexed or 0-indexed is acceptable. * Takes a positive integer `n` and returns or prints the first n terms of this sequence * Takes no input and returns or prints all terms of the sequence with an infinite loop or infinite list Any reasonable form of input and output is allowed. ## Example (0-indexed) ``` Input -> Output 0 -> 0 10 -> 34 40 -> 215 ``` ## Rules * Standard loopholes forbidden. * Code golf: shortest program in bytes for each language wins. [Answer] # [Python 3](https://docs.python.org/3/), 67 bytes Takes no input and prints all terms of the sequence with an infinite loop. ``` n,a=0, while 1:a+=n(all((n-i)*.5%1for i in a)>0!=print(n)),;n+=1 ``` [Try it online!](https://tio.run/##BcFBCoAgEAXQfaewRaBmoUSbYrqLi8IB@YoI0emn9@rXU8EmAmcjeTe8ifOtwhFngtUxZ62xsLF23afwlKZYMVQ0lx@pNkbXMMadmCmI/A "Python 3 – Try It Online") [Answer] # [Ruby](https://www.ruby-lang.org/), ~~72~~ ~~62~~ ~~57~~ ~~50~~ 47 bytes ``` 0.step{\|x\|$<<p(x)if$.all?{\|i\|(x-i)0.5%1>0}} ``` [Try it online!](https://tio.run/##KypNqvz/30CvuCS1oLqmokZFy8amQKNCMzNNRUsvMSfHvroms0ajQjdTU0vLQM9U1dDOoLb2/38A "Ruby – Try It Online") Prints all terms of the sequence indefinitely. 7 bytes saved by Dingus and further 3 by Sisyphus. ## Ruby 2.7+, 45 bytes ``` 0.step{\|x\|$<<p(x)if$.all?{(x-_1)0.5%1>0}} ``` [Answer] # [Python 3](https://docs.python.org/3/), ~~101~~ 93 bytes ``` f=lambda n,l=[],a=0:n and(any((a-b).5%1==0for b in l)and f(n,l,a+1)or f(n-1,l+[a],a+1))or l ``` [Try it online!](https://tio.run/##NVDLboMwELzzFXupsBOnwg9eldwfoRwcAkpU6qBApUZRvp3OovbA7MzseL14ui/na7TrOvgxfB1PgaIafdOq4LO3SCGeRIh3IcLhKHe71/xFe58N1xsd6RJplAjQIHBGhb2W8CEOWo37JrSbxd649j9T3y39iTw1mSKjKFdUKtIQGkpDamjDTWjr8NWKHGrOafQK1AK5ArwEr8BrPpchqDWDcQw81/Jgy5MtS8fMMcu5UW7AsmJWcbdiWTOrt0UwyvB6hncztgI4y4CLTM4eL2UKjvBqpijbpDv33Wd/w2@K9OPblK5L1Ua0TWUS4bs6mVHwTDKZbpe4iCEdxCM@JR3e6TE/6fE3pJm9/3@39pnK9Rc "Python 3 – Try It Online") Inputs a positive integer \$n\$ and returns the first \$n\$ terms of \$A030193\$. [Answer] # [Python 3](https://docs.python.org/3/), ~~102~~ ~~92~~ ~~88~~ 84 bytes ``` f=lambda n,a=[],x=0:n and f([n,n-1,a,a+[x]][all((x-k)*.5%1for k in a)::2],x+1)or a ``` [Try it online!](https://tio.run/##FY3BCsMgEETv/YolUFCzFk3wItgfEQ9bgjTEbkLIIfl6aw5zmfeG2a7ju/JYaw6Ffp@JgJFCTHgG4xmIJ8hCRUbWFgmpj2dKkUoR4tSLVOrlnjavOywwN116P7Rtb2WrqN6AbxAtwojgEKxBGFqcSf4B2z7zIRih0@8O2xVLWf8 "Python 3 – Try It Online") -4 bytes thanks to movatica* [Answer] # [Husk](https://github.com/barbuz/Husk), 17 bytes ``` ¡λVoΛoS≠⌊√M≠⁰N);0 ``` [Try it online!](https://tio.run/##yygtzv7/qG2iocGjpsb/hxae2x2Wf252fvCjzgWPeroedczyBbEaN/hpWhv8/w8A "Husk – Try It Online") Returns an infinite list. The header is used to take 10 elements from it so the result can be displayed. ## Explanation ``` ¡λVoΛoS≠⌊√M≠⁰N);0 ;0 start with [0] ¡ iterate on this array, appending results: λ ) lambda function (argument → ⁰) Vo N first natural number where M≠⁰ differences with elements so far Λo are all S≠⌊√ not square? ``` [Answer] # [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 46 bytes ``` .+ $¶ +1m`^(_)¶(_+¶)((\3__\|^_))\1$ $&_ %`_ ``` [Try it online!](https://tio.run/##K0otycxL/P9fT5tLRevQNi5tw9yEOI14Lc1D2zTitQ9t09TS0Igxjo@viYvX1NSKMVThUlGL51JNiP//38QAAA "Retina 0.8.2 – Try It Online") Outputs the 0ᵗʰ to nᵗʰ terms. Explanation: The program first matches the 0ᵗʰ and nᵗʰ terms, which initially differ by zero, and increments the nᵗʰ term. On the next pass through the loop, it discovers that the nᵗʰ term differs from the first entry by one, and so increments it again. The difference is now two, so this pair of terms no longer matches. Instead, further passes start incrementing previous terms, until finally the 1ˢᵗ term has been incremented to two. At this point, the 0ᵗʰ term cannot be paired with any other term, so now the 1ˢᵗ term is paired with the nᵗʰ term, as they are both two. The nᵗʰ term thus gets incremented twice to four. At this point however the 0ᵗʰ and nᵗʰ terms can be matched again, so the nᵗʰ term gets incremented to five. Now further passes can start incrementing previous terms, until finally the 2ⁿᵈ term has been incremented to five. Having for now exhausted all matches of the 0ᵗʰ and 1ˢᵗ terms, the 2ⁿᵈ term is now paired with the nᵗʰ term. As before, it gets incremented twice, then further passes increment previous terms, until finally the 3ʳᵈ term has been incremented to seven. Eventually all of the terms get incremented until no two terms differ by a square. (It is however important that only one term gets incremented on each pass, otherwise some terms may get incremented prematurely, being the sum of a square of a term whose value is itself still the sum of a square of a term.) ``` .+ $¶ ``` Generate an array of n+1 terms, all of which start off at zero. ``` +` ``` Repeat while two terms have a square difference... ``` 1` ``` ... update one pair of terms... ``` m`^(_)¶(_+¶)((\3__\|^_))\1$ ``` ... match a term, any number of terms, then an term which is a square number plus the initially matched term... ``` $&_ ``` ... and add one to that term. ``` %`_ ``` Convert each term to decimal. At a cost of 2 bytes, using a lookbehind allows all of the terms to be incremented simultaneously, dramatically improving performance: ``` .+ $¶ +m`$(?<=^\2(¶_+)¶(_)((\3__\|_$))) _ %`_ ``` [Try it online!](https://tio.run/##K0otycxL/P9fT5tLRevQNi7t3AQVDXsb27gYI41D2@K1NYGCGvFamhoaMcbx8TXxKpqaWppc8VyqCfH//5sYAAA "Retina 0.8.2 – Try It Online") [Answer] # JavaScript (ES7), 66 bytes Returns the n-th term, 0-indexed. ``` n=>n&&(k=0,g=a=>a[n]\|\|g(++ka.every(v=>(k-v).5%1)?[...a,k]:a))`` ``` [Try it online!](https://tio.run/##FcqxDoIwEADQ3a@4AckdhQYHFrX4IYSkFwSiJVcDpokBvr3q9Jb35MBLNz9e70L8vY@DiWJqSVN0psxHw6bmRtptG1Epl7HuQz9/MJgaXREoy3R1PNGt0Vpz7tozE1kbBz@jgIHyAgJXqP4qRbAeADovi596PfkRLWOyyk6/mqwDCu2WDnv8Ag "JavaScript (Node.js) – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 14 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` ŻJ²p⁸§Ṭ¬TŻḣðƬṪ ``` A monadic Link accepting a positive integer \$N\$ that yields a list of the first \$N\$ terms. [Try it online!](https://tio.run/##ASkA1v9qZWxsef//xbtKwrJw4oG4wqfhuazCrFTFu@G4o8Owxqzhuar///80MQ "Jelly – Try It Online")* ### How? Iterates towards the greedy solution. It would be easier to follow as `0ð...` but we can start the `Ƭ`-loop with \$N\$ rather than \$0\$ saving those two bytes. ``` ŻJ²p⁸§Ṭ¬TŻḣðƬṪ - Link: N Ƭ - start with a left argument of N, apply repeatedly until no change, collecting the left arguments in a list: ð - dyadic chain - f(L=current left argument, N) Ż - when L is an integer [0..L] (first pass only) when L is a list [0]+L (all other passes) J - range of length -> [1..n+1] (all passes due to ḣ, below) ² - square these -> [1,4,9,...,(n+1)²] ⁸ - L (on the first pass L is N and this is implicitly cast to [1..N]) p - (squares) Cartesian product (L) § - sums -> numbers which are any of L plus any of these squares Ṭ - untruth -> a binary list with ones at those indices ¬ - logical NOT T - truth -> a list of the indices of the truthy entries i.e. a bunch of numbers that aren't in the result of the sums, § Ż - prepend a zero ḣ - head to length (N) Ṫ - tail ``` As an example of the `Ƭ`-loop consider \$N=3\$: ``` >>> L = 3 ŻJ² -> [1, 4, 9, 16] ŻJ²p⁸ -> [[1, 1], [1, 2], [1, 3], [4, 1], [4, 2], [4, 3], [9, 1], [9, 2], [9, 3], [16, 1], [16, 2], [16, 3]] ŻJ²p⁸§ -> [2, 3, 4, 5, 6, 7, 10, 11, 12, 17, 18, 19] ŻJ²p⁸§Ṭ¬TŻ -> [0, 1, 8, 9, 13, 14, 15, 16] ŻJ²p⁸§Ṭ¬TŻḣ -> [0, 1, 8] >>> L = [0, 1, 8] ŻJ² -> [1, 4, 9, 16] ŻJ²p⁸ -> [[1, 0], [1, 1], [1, 8], [4, 0], [4, 1], [4, 8], [9, 0], [9, 1], [9, 8], [16, 0], [16, 1], [16, 8]] ŻJ²p⁸§ -> [1, 2, 9, 4, 5, 12, 9, 10, 17, 16, 17, 24] ŻJ²p⁸§Ṭ¬TŻ -> [0, 3, 6, 7, 8, 11, 13, 14, 15, 18, 19, 20, 21, 22, 23] ŻJ²p⁸§Ṭ¬TŻḣ -> [0, 3, 6] >>> L = [0, 3, 6] ŻJ² -> [1, 4, 9, 16] ŻJ²p⁸ -> [[1, 0], [1, 3], [1, 6], [4, 0], [4, 3], [4, 6], [9, 0], [9, 3], [9, 6], [16, 0], [16, 3], [16, 6]] ŻJ²p⁸§ -> [1, 4, 7, 4, 7, 10, 9, 12, 15, 16, 19, 22] ŻJ²p⁸§Ṭ¬TŻ -> [0, 2, 3, 5, 6, 8, 11, 13, 14, 17, 18, 20, 21] ŻJ²p⁸§Ṭ¬TŻḣ -> [0, 2, 3] >>> L = [0, 2, 3] ŻJ² -> [1, 4, 9, 16] ŻJ²p⁸ -> [[1, 0], [1, 2], [1, 3], [4, 0], [4, 2], [4, 3], [9, 0], [9, 2], [9, 3], [16, 0], [16, 2], [16, 3]] ŻJ²p⁸§ -> [1, 3, 4, 4, 6, 7, 9, 11, 12, 16, 18, 19] ŻJ²p⁸§Ṭ¬TŻ -> [0, 2, 5, 8, 10, 13, 14, 15, 17] ŻJ²p⁸§Ṭ¬TŻḣ -> [0, 2, 5] >>> L = [0, 2, 5] ŻJ² -> [1, 4, 9, 16] ŻJ²p⁸ -> [[1, 0], [1, 2], [1, 5], [4, 0], [4, 2], [4, 5], [9, 0], [9, 2], [9, 5], [16, 0], [16, 2], [16, 5]] ŻJ²p⁸§ -> [1, 3, 6, 4, 6, 9, 9, 11, 14, 16, 18, 21] ŻJ²p⁸§Ṭ¬TŻ -> [0, 2, 5, 7, 8, 10, 12, 13, 15, 17, 19, 20] ŻJ²p⁸§Ṭ¬TŻḣ -> [0, 2, 5] >>> [0, 2, 5] >>> seen previously, so stop the Ƭ-loop and yield: [3, [0, 1, 8], [0, 3, 6], [0, 2, 3], [0, 2, 5]] Ṫ -> [0, 2, 5] ``` [Answer] # [Haskell](https://www.haskell.org/), 56 bytes ``` n!l\|or[elem(n-yy)l\|y<-[0..n]]=(n+1)!l\|m<-n:l=n:n!m 0![] ``` [Try it online!](https://tio.run/##HU6xrsIwENvfV1wlBnikqLmkaYrol1QdOhSBSAMClkr8e7EZ4rNzjuPL@LpNKa1rLtLn/uynNM3bXC7/yy59llPZV4dDHoZum/d2B8t8KvMxdfmYi/nv3FVFP6zzeM3SyeN5zW/ZyHu8TeKjnNfKiBqpjTRGLISFspAWWrmEdh6nNeIxa7qxC5gBvgDegEfwlu8qGK0lqCcw1zHYMdlRejJPVnPR/IAykkVuI2VL1v6KIEpZT9lNXQR4R8BHWvOOpTTQwmoami8 "Haskell – Try It Online") `0![]` is an infinite list of the results. This draws some inspiration from [AZTECCO's answer](https://codegolf.stackexchange.com/a/220171/56656). [Answer] # [R](https://www.r-project.org/), ~~85~~ ~~76~~ ~~67~~ 63 bytes Edit: -9 bytes thanks to Giuseppe, and then -4 bytes thanks to Kirill L.* ``` s=0;repeat{s=c(F,s);show(+F);while(any((0:F)^2%in%(F-s)))F=F+1} ``` [Try it online!](https://tio.run/##K/r/v9jWwLootSA1saS62DZZw02nWNO6OCO/XEPbTdO6PCMzJ1UjMa9SQ8PAyk0zzkg1M09Vw023WFNT083WTduw9v9/AA "R – Try It Online") Outputs the infinite sequence. [Answer] # [K (ngn/k)](https://git.sr.ht/%7Engn/k), ~~31~~ 29 bytes ``` {\|x{x,{y+\|/~1!%y-x}[x]/0}/0} ``` [Try it online!](https://ngn.bitbucket.io/k/#eJxLs6rWqqmortCprtSu0a8zVFSt1K2oja6I1TeoBSIurjR1AwVDAwUTAwAuTQxx) Returns the n-th item of the series (0-indexed). If it's acceptable to return the first `n+1` terms of the sequence, the leading `\|` can be dropped to save two bytes. * `{\|...}` return only the last item of the generated sequence + `x{...}/0` run a fold-do loop, for `x` iterations seeded with `0` - `{...}[x]/0` run a fold-converge loop, fixing `x` (the generated sequence so far), seeded with `0`. this will stop when the next value in the sequence has been identified `%y-x` take the square root of the differences between the current loop value and each value in the generated sequence so far * `~1!` check if any difference is a square number (i.e. if it has a remainder of zero after being mod'd by 1) * `y+\|/` increment the current loop value if it is not the next term in the sequence + `{x,...}` append the next value in the sequence [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 76 75 69 64 bytes Takes no input, outputs the infinite series (up to the maximum for a 64-bit signed integer) ``` for(){($a+=,+$n!($a\|?{!([Math]::Sqrt($n-$_)%1)}).Count)-eq$n++} ``` [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/Py2/SEOzWkMlUdtWR1slT0sRyKyxr1bUiPZNLMmItbIKLiwq0VDJ01WJ11Q11KzV1HPOL80r0dRNLVTJ09au/f8fAA "PowerShell – Try It Online") [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 55 bytes returns the first n terms ``` Nest[#~Join~{While[Or@@AtomQ/@√(++k-#)];k}&,{k=0},#]& ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78n2773y@1uCRauc4rPzOvrjo8IzMnNdq/yMHBsSQ/N1Df4VHHLA1t7WxdZc1Y6@xaNZ3qbFuDWh3lWLX/AUWZeSUKDunRhgYGsf//AwA "Wolfram Language (Mathematica) – Try It Online") -11 bytes thanks to @att [Answer] # [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 51 bytes ``` g@n_:=g@m_/;AtomQ@√(m-n)=Print@n i=0 g@i++~Do~∞ ``` [Try it online!](https://tio.run/##y00syUjNTSzJTE78/z/dIS/eyjbdITde39qxJD830OFRxyyNXN08TduAosy8Eoc8rkxbA650h0xt7TqX/LpHHfP@/wcA "Wolfram Language (Mathematica) – Try It Online") Outputs the list indefinitely. [Answer] # [Japt](https://github.com/ETHproductions/japt), ~~27 23~~ 22 bytes ``` @A{ZmaA fAõ² l}fXÄ}h0ô ``` [Try it online!](https://tio.run/##y0osKPn/38GxOio30VEhzfHw1kObFHJq0yIOt9RmGBze8v@/oYGCbiAA) Returns the first `n` numbers in the sequence. If you [replace](https://tio.run/##y0osKPn/38GxOio30VEhzfHw1kObFHJq0yIOt9SmGxze8v@/oYGCbiAA) `h` with `g` it instead returns the `n`th number in the sequence (0-indexed). Improvements: Used "difference is in list of squares" instead of "square root of difference is an integer" to save 4 bytes, inspired by Jonathan Allan's Jelly answer * Used `0ô` to initialize the array as suggested by AZTECCO Explanation: ``` @A{ZmaA fAõ² l}fXÄ}h0ô 0ô # Starting with [0] @ }h # Add elements to the array until the length is n: A{ }fXÄ # Find the next integer A that returns 0: Zm # For each element already in the array: aA # Get the absolute difference between it and A f # Remove any elements that are also in: Aõ² # All squares up to A^2 l # Count how many elements are left ``` [Answer] # JavaScript, 66 bytes ``` _=>{a=[];for(i=0;;i++)a.every(x=>(i-x).5%1)&&a.push(i);return a} ``` Adds the terms of the sequence to an array with an infinite loop. [Try it online!](https://tio.run/##Hc3RCsIgFIDh@57i3DR0Y64ugkAc9BwRcZhHZjQ1p2MRPbuN7j7@m/@BC85DtCG1y7kYVbruojVpCNG6BMmDzynkBITDCPSkibbsDcz0yuQG2t1V/0F1vUnjI7PqIKVtGo6CFopvtqqe2XbldS1O@yOvKhQhzyOzG/@LTTJSytEBfothvPwA) # JavaScript (V8), ~~77~~ 76 bytes ``` n=>{a=[];for(i=0;a.length<n;i++)a.every(x=>(i-x).5%1)&&a.push(i);print(a)} ``` Prints the first `n` terms of the sequence. [Try it online!](https://tio.run/##BcFRCoMwDADQ0yiJYlFwsFHjRcSPIO3MGLXUWpSxs9f3Ppx4X4L42KRntpQdjT@madZ2CyDUalZf495xHZyWukZWJplwwUkjSHNiValH0WFZsvLHvoKg9kFcBMZ/ttC/MN8) ## Explanation ``` n=>{ a=[];//array of terms in the sequence for(i=0;a.length<n;i++) //loop until array length is n a.every(x=>(i-x)*.5%1) //check if square root of delta with each previous number in sequence is not an integer &&a.push(i);//then add to array print(a)//output array (return works too) } ``` [Answer] # [J](http://jsoftware.com/), 35 bytes ``` 0&(],]>:@]^:(1 e.(=<.)@%:@-)^:_[)0: ``` [Try it online!](https://tio.run/##HU5dS8NAEHzPrxgEbQ4uIfeR5HJYCQo@iQ99lVRKvNAItmIj@O/jTh92duZ2bnc@15tyM2EbsYFGhShVlHjavTyv1V0@6OEh9sM@5gapzLf3pepvY1@ofXx/U1VcVZa9PpbYpeX353SBwTwh/X2ncTks8/mE@YKvwzIe00eWpfF4Rj7BB4VCDmlYjVqj1TAijCgj0oi2HIp2XqrT8NJrumXWSG/E1whvhQfhHf9VYjSGYD2Bex0XO252lJ7Mk9UctFegDGSB00DZkXXXILLKMp5lNuuCgHcEOWRrvjGUbWhhNNu06z8 "J – Try It Online") Given `n`, returns the first `n+1` terms. [Answer] # Scala, 109 bytes ``` Stream.iterate(0::Nil)(s=>Stream.from(s(0)).find(x=> !s.exists(Set(0 to x:_)map(a=>x-aa))).get::s)map(_(0)) ``` [Try it in Scastie!](https://scastie.scala-lang.org/mJxFCIUaRRmPXjr9m1iK7w) An infinite Stream. ## First n elements, 100 bytes ``` Stream.iterate(0::Nil)(s=>Stream.from(s(0)).find(x=> !s.exists(Set(0 to x:_)map(a=>x-aa))).get::s) ``` This is the exact same code, just without the `map(_(0))` part at the end. Given an n, it gives the first n elements of the sequence, but in reverse. ### Another 100 byte solution ``` 1.to(_)./:(0::Nil)((s,_)=>Stream.from(s(0)).find(x=> !s.exists(Set(0 to x:_)map(a=>x-aa))).get::s) ``` [Try it in Scastie](https://scastie.scala-lang.org/5xKNcueZRpu8nomnCkrQOQ) Explanation: ``` Stream.iterate //Build an infinite Stream by repeatedly applying a function to (0::Nil) //A List containing only a 0 (s=> //The previous elements (in reverse) Stream.from(s(0)) //Make a Stream starting from the last element .find(x=> //Find a number with no square difference !s.exists( //Make sure none of the previous elements are in this Set: Set(0 to x:_) //Start with a set of integers from 0 to x map(a=>x-aa) //Subtract square from x (to get all elements with squared differences) ) ).get //Unwrap the Option (as the sequence is infinite) ::s //Prepend to s, the sequence )map(_(0)) //Get the first (or rather, last) element of each partial sequence ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~15~~ 14 bytes ``` ;0_Æ²Ẹ¬ʋ1#$$¡Ṗ ``` [Try it online!](https://tio.run/##ASIA3f9qZWxsef//OzBfw4bCsuG6uMKsyosxIyQkwqHhuZb//zUw "Jelly – Try It Online") Prints the first n terms. If we allow outputting the first n+1 items (as some answers are doing), then it's 13 bytes (without the last character). -1 byte thanks to Jonathan Allan* [Answer] # [Haskell](https://www.haskell.org/), ~~95~~ 89 bytes ``` n!l\|and[yy/=n-x\|x<-l,y<-[0..n-x]]=n:l\|m<-n+1=m!l f n=iterate(\l@(h:t)->(h+1)!l)[0]!!n!!0 ``` [Try it online!](https://tio.run/##JY7NboMwEITvfYq11AM0JsU/GBNB1fegHJBCBKqxooQDSLw73UkPHs/HrocZ@@fvEMJxRBH2Pl7b7WP7bGK27mudBbnVWZufz8xd18RL2Oc6iyfVzCK83Sg20zI8@mVIfsJ3Ml6WNPtKxpNKRUjbvBMiCpEfcz9Fauj@mOJC7y3daKWdz3@09V135JK0pEJSKUkxKCbFqJg1hszG8qkkWb4LbPPM8e14z7Ev2Xv2Fd7lvKgURFsIcg2CDZIN0MJZuAKD8iVAD@cx9cAKrnoV4SiNehrdtPEs1kD4R7rAN5TSDiuopl35Bw "Haskell – Try It Online") saved 6 thanks to @Wheat Wizard ! * uses this tip [Don't waste the "otherwise" guard](https://codegolf.stackexchange.com/a/85910/84844) * returns nth term 0-indexed * f(n) - iterates (!) n times, starting with [0] and prepends next term. then takes the element in front because list is reversed. * (!) tries next number at beginning of list: if it satisfy condition returns it prepended to list else try the next [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 34 bytes ``` {∇⍵,⎕←⊃(g~⊢)∊⍵∘.+2⍨(g←⍳2+⌈/)⍵}⎕←0 ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/6sfdbQ/6t2qAxQB8h91NWuk1z3qWqT5qKMLKPyoY4aetpHWo94VGukg6d7NRtqPejr0NYFytRAtBv//AwA "APL (Dyalog Unicode) – Try It Online") ### With a train (and a small dfn), 41 bytes ``` (⊢,(({⎕←⊃⍵}g∘∊~⊢)∘.+∘(2⍨g←⍳2+⌈/)⍨))⍣≡⎕←0 ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkGXCCy@lHvLiBS0AARj3q3AhGI0qz9r/Goa5GOhkY1UD1Q3aOuZqBwbfqjjhmPOrrqgHKaQKaeNpDQMNJ61LsiHaSod7OR9qOeDn1NoIAmkFj8qHMhRL/B//8A "APL (Dyalog Unicode) – Try It Online") [Answer] # [C (gcc)](https://gcc.gnu.org/), 99 bytes ``` m,i,k;f(n,l){l=!!m++;for(i=1;i<m;k%=m,i+=!k)k+=(&l)[i8]+kk-l\|\|(l+=i=k=1);!n?m=0,n=l:f(n-1,l+1);} ``` [Try it online!](https://tio.run/##RVDbbsIwDH1uv8JFYkpI0Jr0vhDtD/gBxsNU2ilKWhDjoRrw7Z3NhPYQ@xz75MROu/5q23kepJPe9GyUgV/DyibJIITpj2fmrDJuMxi/tCgSNvHcC8teAt@5Vb0XfuXX4XZjQVhnvVXcJOP7YFM52vCGhmslg8DqfXbjBYZPNzIeX@OIWDeduvbSHXZ7sHBNJWgJhYRKgkKikCmkCrmmJvIsx9NIyDEXpMZeiblEXYm4QlwjbuheikKlKOicAvlmZJyRc0Y0J5QTKqhRPQLRmlBN3ZpoQ6h5DIJWmsbTNJvOagx5RgEf0gXVaChdkoRG02V1N3/7bnHNb/fTHXv2XJ3D67OECm7iOMJfByIwoTw1mDawNSDExOMoOp2x1bPF8gDWwvLwMS7k/0dOewk9mzgaRfF9/gU "C (gcc) – Try It Online") Takes n as input and returns the n-th number in the sequence (0-indexed) # [C (gcc)](https://gcc.gnu.org/), 78 bytes shorter solution, extremely slow for n > 8 Edit: -2 Bytes thanks to ceilingcat ``` f(n,i,k,r){r=n?f(n-1):0;for(i=k=0;k<n;i>n?i=!++k:++i)k=f(k)+ii-r?k:!++r;n=r;} ``` [Try it online!](https://tio.run/##RY7BasMwEETP0ldsAgHJkrFkKAUrqv8gP5DmUGyrLKJKUHIQNf52Z0MIOQ1vd2aYof4dhnUNImnUUWc5Z596wtrKzrhwzgJ99MbFfXL4lXr0G6VipxTK6IOIUmGFde5jR/fsks9uWTHd4O8Hk5B85uxBU7lMw20ajyfwMBsNrYYPDZ8aLIElsoSWuDXQVCQtVA0s7hk/UOqK/9M5iFeThOZ1Iod0nDNaCw@AQnbjSPZwcKBUkZyxS6ZXENvdCN7DbvxOW/3eVU4agiiSihhf1js "C (gcc) – Try It Online") [Answer] # [Raku](http://raku.org/), 36 bytes ``` 0,{first (-@_.all).sqrt%1,^∞}... ``` [Try it online!](https://tio.run/##K0gtyjH7n1up4JCoYPvfQKc6LbOouERBQ0vXIV4vMSdHU6@4sKhE1VAn7lHHvFo9PT2t/9YKxYkg9dFxRgax/wE "Perl 6 – Try It Online") This is an expression for a lazy, infinite sequence of the required values. [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 13 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` 0λλU∞.ΔXαÅ²≠P ``` Outputs the infinite sequence. [Try it online.](https://tio.run/##ASEA3v9vc2FiaWX//zDOu867VeKIni7OlFjOscOFwrLiiaBQ//8) Should have been 11 bytes by removing `λU` and changing `X` to `λ` (`0λ∞.ΔλαÅ²≠P`), but unfortunately the recursive environment builtin still has some issues here and there, and apparently trying to retrieve the recursive-list `λ` inside a nested loop (`.Δ` in this case) doesn't work. Outputting the first \$n\$ or \$n^{th}\$ value would be 1 byte longer than the infinite list: [try the first \$n\$ online](https://tio.run/##ASUA2v9vc2FiaWX//zDOu8KjzrtV4oieLs6UWM6xw4XCsuKJoFD//zEw) or [try the 0-based \$n^{th}\$ online](https://tio.run/##ASUA2v9vc2FiaWX//zDOu8OozrtV4oieLs6UWM6xw4XCsuKJoFD//zQw). Explanation: ``` λ # Start a recursive environment, # to output the infinite sequence implicitly as result afterwards, 0 # starting a(0)=0, # and where every following a(n) is calculated as follows: λ # Push a list of the previous results of a(0)..a(n-1) U # Pop and store this list in variable `X` ∞.Δ # Find the first positive integer [1,2,3,...] which is truthy for: X # Push list `X` α # Get for each the absolute difference with the current integer Å² # Check for each whether it's a square number ≠ # Invert each boolean, so we check they're NOT a square number P # And check if this is truthy for all of them ``` ]
[Question] [ This task is simple: Write a program or function that outputs the list of all musical notes (using English note names) from A♭ to G♯. All notes without a name consisting of a single letter (i.e. black notes on a musical keyboard) should have their name printed twice, once as the sharp of a note, once as the flat of one. Sharp or flat notes that can be described with a single letter, like B♯ (C) or F♭ (E) should not be outputted. Here is an example of the output: ``` Ab, A, A#, Bb, B, C, C#, Db, D, D#, Eb, E, F, F#, Gb, G, G# ``` # Specifications * The program or function must not take any input. * The notes may be printed in any order, and in any list output permitted by our [standard I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) * The sharp and flat Unicode symbols (♯/♭) may be substituted with `b` and `#` * As always, [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden. * As this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the smallest program, in bytes, wins. [Answer] # [Malbolge](https://github.com/TryItOnline/malbolge), ~~482~~ ~~370~~ 353 bytes R1: Removed commas inbetween (as not required by the challenge) R2: Shave off a few bytes ``` ('<;_#!=6Z\|{8xUwvt,PrqonKmk)"FhCUTdb?`+<;:[Z7YtVU2T\|/g-O+i(gJrHc#EC~B{@zZxw:tt'r5Qo"!l/K-hUfe?bP``_Lo~[}\|X2VCTR3Q+N`_^9+7Hji3ffdAc~w\|u;]\wpon4VUSSQ.PONcb(JI^]#DCYX\|@?>=<:u9NMRKo32MFj.C,Ae)>'<%:^"!~5:3WxwwuRts0q(Lnml)"Fhgfe"y?a`_zyxq7YXWlUj0RgfkjMb(JI^c\[Z~BAV?T=Rv987Mq44310FEi-,G@)>b&%#"8=6Z{{yyw/Sut1)('Km$k(!Efe{zyx>`uz]r8ZXnm3TTih.PkNchg`&HFF[DY}Az ``` [Try it online!](https://tio.run/##HdCLdoEAAIDhZylDlnsscgnRDLmkqNxSKpfSWIlKr95sL/Cd//zGVpdMXVPCEIpXK5sIUPsQfK90Z52blRxfL@a5b5wSILknWGYn4SJcrWALAeWtGZtn/IyWGsEHSOtdu3KkQwQtr@EKdwezrPi1ODFBQM/0U3tWVXBpLIqbgRksnj6XnxEMjUzgobhZl2G0ezwgqrpryoHj25XV0vk2z4UZO51O0uPRUJag3td6FWkTPOc38HqtitnlIUX3TSRPkcc0kWwqiXq8GsXWIBAUMWR@dxybtn6yF2hwNvS/dk1VwAe@FTfu435BeW6us8csramnI/Wvy8uFELSaM5yp0bdyCaUuhQKSy5KdQyr52UjUpVg0ApZeZzzv8XAyU9vKvSegeN94O0FAR1W8l1sXbXd1LQnc2UAY5rBPj09Dea@JsS5JLtr8s@mG4S8 "Malbolge – Try It Online") [Answer] # [CP-1610](https://en.wikipedia.org/wiki/General_Instrument_CP1600) assembly ([Intellivision](https://en.wikipedia.org/wiki/Intellivision)), 31 DECLEs1 = 39 bytes A routine taking an output pointer in R4* and writing the notes there, separated with spaces. In the example code, we write directly to the screen. ### Hex dump (routine only) ``` 275 001 2BD 03C 048 1DB 2B8 012 044 2A9 2BA 108 078 201 003 262 261 263 2FA 008 37A 140 225 00B 089 22C 011 2B7 018 210 000 ``` ### Full source ``` ROMW 10 ; use 10-bit ROM width ORG $4800 ; map this program at $4800 ;; ------------------------------------------------------------- ;; ;; test code ;; ;; ------------------------------------------------------------- ;; 4800 SDBD ; set up an interrupt service routine 4801 MVII #isr, R0 ; to do some minimal STIC initialization 4804 MVO R0, $100 4806 SWAP R0 4807 MVO R0, $101 4809 EIS ; enable interrupts 480A MVII #$200, R4 ; R4 = backtab pointer 480C CALL notes ; invoke our routine 480F DECR R7 ; loop forever ;; ------------------------------------------------------------- ;; ;; ISR ;; ;; ------------------------------------------------------------- ;; isr PROC 4810 MVO R0, $0020 ; enable display 4812 CLRR R0 4813 MVO R0, $0030 ; no horizontal delay 4815 MVO R0, $0031 ; no vertical delay 4817 MVO R0, $0032 ; no border extension 4819 MVII #$D, R0 481B MVO R0, $0028 ; light-blue background 481D MVO R0, $002C ; light-blue border 481F JR R5 ; return from ISR ENDP ;; ------------------------------------------------------------- ;; ;; routine ;; ;; ------------------------------------------------------------- ;; notes PROC 4820 PSHR R5 ; save return address 4821 SDBD ; R5 = pointer to @@chr 4822 MVII #@@chr, R5 4825 CLRR R3 ; R3 = 0 (space) 4826 MVII #$12, R0 ; R0 = bitmask = $12 4828 SWAP R0, 2 ; extend it to $1212 4829 @@loop MVI@ R5, R1 ; R1 = next symbol 482A MVII #('A'-32)8, R2 ; R2 = 'A' character 482C @@note SARC R0 ; right shift the bitmask 482D BC @@next ; skip this note if the carry is set 482F MVO@ R2, R4 ; append the note 4830 MVO@ R1, R4 ; append the symbol 4831 MVO@ R3, R4 ; append a space 4832 @@next ADDI #8, R2 ; advance to the next note 4834 CMPI #('H'-32)8, R2 ; is it now a 'H'? 4836 BLT @@note ; if not, process the inner loop 4838 TSTR R1 ; was the symbol a space? 4839 BNEQ @@loop ; if not, process the outer loop 483B PULR R7 ; return 483C @@chr DECLE ('#'-32)8 ; '#' 483D DECLE ('b'-32)8 ; 'b' 483E DECLE 0 ; space ENDP ``` ### Output [![output](https://i.stack.imgur.com/Tui88.gif)](https://i.stack.imgur.com/Tui88.gif) screenshot from [jzIntv](http://spatula-city.org/~im14u2c/intv/) --- 1. A CP-1610 opcode is encoded with a 10-bit value, known as a 'DECLE'. This routine is 31 DECLEs long, starting at $4820 and ending at $483E (included). [Answer] # [Python 3](https://docs.python.org/3/), 50 bytes ``` print(map(''.join,zip(3'ADGBCEF',7' '+5'#b'))) ``` [Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQys3sUBDXV0vKz8zT6cqs0DDWEvd0cXdydnVTV3HXEtdQV3bVEtdOUldU1Pz/38A "Python 3 – Try It Online") Python 2: [48 bytes](https://tio.run/##K6gsycjPM/r/v6AoM69EITexQENdXS8rPzNPpyqzQMNYS93Rxd3J2dVNXcdcS11BXdtUS105SV1T8/9/AA "Python 2 – Try It Online") This code can be adjusted as to include B# and Cb, at the cost of no additional bytes. This can be achieved by replacing `5` with `6`. --- Additionally, it is (finally) shorter than just outputting the plain string: # [Python 3](https://docs.python.org/3/), 51 bytes ``` exit('Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G#') ``` [Try it online!](https://tio.run/##BcGxDYAwDADBVV5yEaiZwIkT72EJCRqgSAHTm7vnm8d9bZn7e86laKCoUINKowkWGCb0oDMYggeOS1kzfw "Python 3 – Try It Online") Python 2: [50 bytes](https://tio.run/##BcGxDcAgDADBVV5yQZ8NDAbv4SppAEU0md6529@517wy9/vMUzRQVKhBpdEECwwTetAZDMEDx6Vk/g "Python 2 – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~16~~ ~~15~~ 13 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` Au…b #âŽ7×bûÏ ``` -2 bytes thanks to @maxb. [Try it online.](https://tio.run/##AR4A4f9vc2FiaWX//0F14oCmYiAjw6LFvTfDl2LDu8OP//8) Outputs as a list, where the single-char notes are with a trailing space. Explanation: ``` Au # Push the lowercase alphabet, and uppercase it …b # # Push string "b #" â # Take the cartesian product of both strings to create all possible pairs: # ["Ab","A ","A#","Bb","B ","B#",...,"Zb","Z ","Z#"] Ž7× # Push compressed integer 1999 b # Convert it to a binary string "11111001111" û # Palindromize it to "111110011111110011111" Ï # Only leave the notes in the list at the truthy values (1), (the trailing # items beyond the length of this binary string are also discarded) # (after which the result is output implicitly) ``` [See this 05AB1E tip of mine (section How to compress large integers?)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Ž7×` is `1999`. `Ž7×` could alternatively be `₄·<` (1000, double, decrease by 1) for the same byte-count. [Answer] # [Perl 6](https://github.com/nxadm/rakudo-pkg), 41 bytes ``` {S:g/[E\|B]\#...//}o{'A'..'G'X~'b #'.comb} ``` [Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/OtgqXT/atcYpNkZZT09PX782v1rdUV1PT91dPaJOPUlBWV0vOT83qfZ/cWKlQpqG5n8A "Perl 6 – Try It Online") Simple cross product of the notes and the sharps/flats, followed by removing the extra invalid notes. This is an anonymous code block that produces the string: ``` Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G# ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 18?\* 20 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ``` ØAḣ7µp⁾b#Żs6ḣ€4ẎḊ;W€ ``` A monadic Link returning a list of lists of characters. \* If a mixed list of (a) lists of characters and (b) characters is acceptable remove the trailing `W€` for 18. [Try it online!](https://tio.run/##y0rNyan8///wDMeHOxabH9pa8KhxX5Ly0d3FZkD@o6Y1Jg939T3c0WUdDmT/P7QoCyito/AfAA "Jelly – Try It Online") ### How? ``` ØAḣ7µp⁾b#Żs6ḣ€4ẎḊ;W€ - Link: no argument ØA - list of characters [A-Z] ḣ7 - head to 7 "ABCDEFG" µ - new monadic link (call that X) ⁾b# - list of characters "b#" p - Cartesian product ["Ab","A#","Bb","B#","Cb","C#","Db","D#","Eb","E#","Fb","F#","Gb","G#"] Ż - prepend a zero [0,"Ab","A#","Bb","B#","Cb","C#","Db","D#","Eb","E#","Fb","F#","Gb","G#"] s6 - split into sixes [[0,"Ab","A#","Bb","B#","Cb"],["C#","Db","D#","Eb","E#","Fb"],["F#","Gb","G#"]] ḣ€4 - head each to 4 [[0,"Ab","A#","Bb"],["C#","Db","D#","Eb"],["F#","Gb","G#"]] Ẏ - tighten [0,"Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#"] Ḋ - dequeue ["Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#"] W€ - wrap each (of X) ["A","B","C","D","E","F","G"] ; - concatenate ["Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#","A","B","C","D","E","F","G"] ``` [Answer] # [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 33 bytes ``` ABCDEFG . $&b $& $&# [BE]#... ``` [Try it online!](https://tio.run/##K0otycxL/P@fy9HJ2cXVzZ1Lj0tBRS0JiIFImUsh2sk1VllPT4/r/38A "Retina 0.8.2 – Try It Online") Explanation: ``` ABCDEFG ``` Insert the base note names. ``` . $&b $& $&# ``` Expand each note to include flat and sharp versions. ``` [BE]#... ``` Delete `B#`, `E#` and also the notes following them (`Cb` and `Eb`). [Answer] # [R](https://www.r-project.org/), 50 bytes ``` cat("Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#") ``` [Try it online!](https://tio.run/##BcHBDcAgDATBXrhPkLYJg8F14HSA0r8zc6ve8z3NEsPESAaTKTxxXKxksdkikiDUetUP "R – Try It Online") Boring answer. # [R](https://www.r-project.org/), 60 bytes ``` cat(outer(LETTERS[1:7],c("#","","b"),paste0)[-c(2,5,17,20)]) ``` [Try it online!](https://tio.run/##K/r/PzmxRCO/tCS1SMPHNSTENSg42tDKPFYnWUNJWUlHCYiSlDR1ChKLS1INNKN1kzWMdEx1DM11jAw0YzX//wcA "R – Try It Online") [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal), 21 bytes ``` Φ⪪⭆…α⁷⭆b #⁺ιλ²§↨⊖⊘φ²κ ``` [Try it online!](https://tio.run/##RYvBCsIwEER/JdTLBiKkXjx40oroQSj0C9Z0scFtGtJt0a@PuYiH4cG8GTdgchNyzm3yQeDiWShBF9kLdFK65x0jNB/H1AxTBDRqr436q@qhNpVRLS8zeKNY66J3JUe5hZ7ecMKZ4Ewu0UhBqIcr8lpQW2t/21d5HXLO25W/ "Charcoal – Try It Online") Link is to verbose version of code. Explanation: ``` α Predefined variable uppercase alphabet … ⁷ First 7 letters i.e. `ABCEDFG` ⭆ Map over characters and join b # Literal string `b #` ⭆ Map over characters and join ⁺ιλ Concatenate outer and inner characters ⪪ ² Split back into substrings of length 2 Φ Filter where nonzero φ Predefined variable 1000 ⊘ Halved i.e. 500 ⊖ Decremented i.e 499 ↨ ² Converted to base 2 i.e. [1, 1, 1, 1, 1, 0, 0, 1, 1] § κ Cyclically indexed by outer index Implicitly print matching values on separate lines ``` [Answer] # [Stax](https://github.com/tomtheisen/stax), ~~17~~ 15 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax) ``` ║♠+I▬┌ó£ΔφΔ`╗╨Å ``` [Run and debug it](https://staxlang.xyz/#p=ba062b4916daa29cffedff60bbd08f&i=&a=1) Bonus program: [print the fancy symbols](https://staxlang.xyz/#p=8119b28c65e3c9a847e07684d593273f040372&i=&a=1) [Answer] # [Japt](https://github.com/ETHproductions/japt), ~~23~~ 22 bytes ``` ;B¯7 ï"b #" fÏÄ %9%8<6 ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=O0KvNwrvImIgIyIgZs/EICU5JTg8Ng&input=MCAgMSAgMiAgMyAgNCAgNSAgNiAgNyAgOCAgOSAgMTAgMTEgMTIgMTMgMTQgMTUgMTYgMTcgMTggMTkgMjAKQWIsQSAsQSMsQmIsQiAsICAgICAsQyAsQyMsRGIsRCAsRCMsRWIsRSAsICAgICAsRiAsRiMsR2IsRyAsRyMKCjQsNiwxMywxNQ) ``` ;B Alphabet ¯7 First seven characters ("ABCDEFG") Assign to U ï"b #" Cartesian product with "b #" ("Ab,A ,A#,Bb,B ,B#,Cb,C ,C#,Db,D ,D#,Eb,E ,E#,Fb,F ,F#,Gb,G ,G#") f Filter: ÏÄ Is index + 1 %9%8 Mod 9 Mod 8 <6 Less than 6 End filter ("Ab,A ,A#,Bb,B ,C ,C#,Db,D ,D#,Eb,E ,F ,F#,Gb,G ,G#") ``` [Answer] # dzaima/APL REPL, ~~38~~ ~~28~~ 25 bytes ``` (⊤2056111)⌿,' b#'∘.,⍨7↑⎕A ``` [Try it online!](https://tio.run/##SyzI0U2pSszMTfwPBBqPupYYGZiaGRoaaj7q2a@jrpCkrP6oY4aezqPeFeaP2iY@6pvq@C@/oCQzP6/4v24xAA "APL (dzaima/APL) – Try It Online") [Answer] # [PHP](https://php.net/), 65 bytes Makes the list with a loop. Items are separated by `_` with a trailing separator. ``` for(;$l=ABCDEFG[$i++];)echo$l._.[$a="$l#_",$a.$b=$l.b_,$b][$i%3]; ``` [Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKxVcmwdnZxdXN3co1UytbVjrTVTkzPyVXL04vWiVRJtlVRylOOVdFQS9VSSbIGiSfE6KkmxQKWqxrHW//8DAA "PHP – Try It Online") --- # [PHP](https://php.net/), 43 bytes PHP outputs anything as is, when not inside `<?php` and `?>` tags. ``` Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G# ``` [Try it online!](https://tio.run/##BcGxAQAgCASxYb69JVCEPb6ydP8Gk3ffTJggxDKLzRZpkhTHHIoSbZrWzAc "PHP – Try It Online") [Answer] # Commodore C64/TheC64 Mini (probably other Commodore 8-bit BASIC variants) - 52 tokenized BASIC bytes ``` 0?"{CTRL+N}Ab A A# Bb B C C# Db D D# Eb E F F# Gb GG# ``` Pressing the `CTRL` key plus `N` on the C64 keyboard goes into 'business mode' on the character set for upper/lower case characters. We may print this out in a string in one byte / token; and as we have 40 columns, the space from G to G# is not required. We do not need to close the string in this case as it is not a multi-statemented line with a `:` separator. How this looks on a Commodore C64 (and compatibles) screen is shown below. [![Commodore 64 musical notes](https://i.stack.imgur.com/6nZ8a.png)](https://i.stack.imgur.com/6nZ8a.png) [Answer] # [Ruby](https://www.ruby-lang.org/), 43 bytes ``` p (2..18).map{\|i\|"FCGDAEB"[i%7]+"b #"[i/7]} ``` [Try it online!](https://tio.run/##KypNqvz/v0BBw0hPz9BCUy83saC6JrNGyc3Z3cXR1UkpOlPVPFZbKUlBGcjUN4@t/f8fAA "Ruby – Try It Online") With the range `0..20` this would print an array containing all the flats, all the naturals and all the sharps. The undesired ones `Fb Cb E# B#` are omitted by using the range `2..18` The notes are printed out ordered according to <https://en.wikipedia.org/wiki/Circle_of_fifths> , or in other words ascending by 7 semitones (a frequency ratio of almost exactly 1.5) each time. This leads to the note letter order given, in which each note is five degrees inclusive (known as a "fifth") above the previous one. For example `F->C` is `FGABC` [Answer] # [brainfuck](https://github.com/TryItOnline/brainfuck), 106 bytes ``` +++[[-<+>>++<]>]<<[-<->]++<<++<,+<-<[->+>+<<]<+[>>>>>+>-[<.<<<.>.[<]]>[>]<+[---<.<.<.[<]]>[>]<++<.<<.<<<-] ``` [Try it online!](https://tio.run/##RYpBCoBADAMfFLMvCPlI6UEFQQQPgu9f25MpOcw027Oe9/Hu15wAIijYgNIpFdFZpOoCsYzh4hTCHZihIWl4hDId7h/JsnW/Q896yZzzAw "brainfuck – Try It Online") Outputs each note separated by carriage returns. [Answer] # [Zsh](https://www.zsh.org/), 36 bytes ``` <<<${${(F):-{A..G}{b,,#}}//[BE]#???} ``` An uglier solution, but it saves two characters. `(F)` joins a list on newlines, and `//[BE]#???` removes the parts of the string we need. [Try it online!](https://tio.run/##qyrO@P/fxsZGpVqlWsNN00q32lFPz722OklHR7m2Vl8/2sk1Vtne3r72/38A "Zsh – Try It Online") --- ## [Zsh](https://www.zsh.org/), 38 bytes ``` <<<${${:-{A..G}{b,,#}}:#([BE]#\|[CF]b)} ``` I always enjoy it when Zsh beats Perl (hopefully I don't speak too soon...). ``` <<<${${:-{A..G}{b,,#}}:#([BE]#\|[CF]b)} ${:- } # empty-fallback, basically an anonymous parameter expansion {A..G}{b,,#} # Cross product range A-G with b,(nothing),# ${ :# } # Remove matching elements ([BE]#\|[CF]b) # B#, E#, Cb, Fb <<< # Print to stdout ``` [Try it online!](https://tio.run/##qyrO@P/fxsZGpVql2kq32lFPz722OklHR7m21kpZI9rJNVa5JtrZLTZJs/b/fwA "Zsh – Try It Online") [Answer] # [Lost](https://github.com/Wheatwizard/Lost), 105 bytes ``` v<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> >%?"Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G\9"-+@ ``` Outputs with `#b` and space delimiter. [Try it online](https://tio.run/##dcG9CYAwEIDR3ik@EqwkAwgSvfwuYXW1YKG4/jlB3rvu5zX7tqE4MsV5d6II4klKIpM9RSkUT1UqjebpSqefqwvLYWZBfg) or [verify that it's deterministic](https://tio.run/##dcG7CYBAEEDB3CoeLkZyBQhyev8OjIw2FgwU218ruJnrfl6zb@3yPYOftjEogSBEJZJIQlYyWShKoVKFpjTauYxu3s3MBXPHDw). ### Explanation: Explanation of the language in general: Lost is a 2D path-walking language. Most 2D path-walking languages start at the top-left position and travel towards the right by default. Lost is unique however, in that *both the start position AND starting direction it travels in is completely random. So making the program deterministic, meaning it will have the same output regardless of where it starts or travels, can be quite tricky. A Lost program of 2 rows and 5 characters per row can have 40 possible program flows. It can start on any one of the 10 characters in the program, and it can start traveling up/north, down/south, left/west, or right/east. In Lost you therefore want to lead everything to a starting position, so it'll follow the designed path you want it to. In addition, you'll usually have to clean the stack when it starts somewhere in the middle. Explanation of the program:* All arrows, including the reflect `\` in the string, will lead the path towards the leading `>` on the second line. From there the program flow is as follows: * `>`: travel in an east/right direction * `%`: Put the safety 'off'. In a Lost program, an `@` will terminate the program, but only when the safety is 'off'. When the program starts, the safety is always 'on' by default, otherwise a program flow starting at the exit character `@` would immediately terminate without doing anything. The `%` will turn this safety 'off', so when we now encounter an `@` the program will terminate (if the safety is still 'on', the `@` will be a no-op instead). * `?`: Clean the top value on the stack. In some program flows it's highly likely we have a partial string on the stack, so we use this to wipe the stack clean of that potential string. * `"`: Start a string, which means it will push the integer code-points of the characters used. * `Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G\9`: Push the code-points for these characters, being `65 98 32 65 32 65 35 32 66 98 32 66 32 67 32 67 35 32 68 98 32 68 32 68 35 32 69 98 32 69 32 70 32 70 35 32 71 98 32 71 32 71 92 57` respectively * `"`: We're done pushing code-points of this string * `-+`: Subtract the top two values from one another: (92-57=) `35` * `@`: Terminate the program if the safety is 'off' (which it is at this point). After which all the values on the stack will be output implicitly. Using the `-A` program argument flag, these code-points will be output as characters instead. Minor note: The top part could also have been `v<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<` instead. Lost will wrap around to the other side when moving in a direction. So using `v<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>` could be a slightly shorter path, and since it's the same byte-count anyway, why not use it. :) [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 21 bytes ``` ØAḣ7;p¥⁾b#“¿€×Ø‘œPẎẎ€ ``` [Try it online!](https://tio.run/##y0rNyan8///wDMeHOxabWxccWvqocV@S8qOGOYf2P2pac3j64RmPGmYcnRzwcFcfEAGF/h9uPzrp4c4Z/wE "Jelly – Try It Online") [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 36 bytes ``` "#b"ẹ,Ẹ↺;Ṇh₇ᵗ↔{∋ᵐc}ᶠ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩ ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r/X0k5Senhrp06D3fteNS2y/rhzraMR03tD7dOf9Q2pfpRR/fDrROSax9uW/Bo/gqgRGtyyaOmxkdNLY/mr4SIADlNIMFWoMj///@jAA "Brachylog – Try It Online") I'm currently in the process of brute-forcing the powerset index that would let me get rid of `⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩` (and by extension `↺`, since the output doesn't need to be in the same order as the example output), but it's taking quite a while... maybe I should put a minute aside to actually work out what order sublists are generated in, and compute the index that way... [Answer] # [Canvas](https://github.com/dzaima/Canvas), 23 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md) ``` Ｚ７ｍ｛#＋¹¹b＋］｛“╷!↕„２┬²＠？Ｐ ``` [Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjNBJXVGRjE3JXVGRjREJXVGRjVCJTIzJXVGRjBCJUI5JUI5YiV1RkYwQiV1RkYzRCV1RkY1QiV1MjAxQyV1MjU3NyUyMSV1MjE5NSV1MjAxRSV1RkYxMiV1MjUyQyVCMiV1RkYyMCV1RkYxRiV1RkYzMA__,v=8) [22 bytes](https://dzaima.github.io/Canvas/?u=JXUyNTc3JTIxJXUyMTk1JXUyMDFFJXVGRjNBJXVGRjE3JXVGRjREJXVGRjVCJTIzJXVGRjBCJUI5JUI5YiV1RkYwQiV1RkYzRCV1RkY1QiV1RkYxQiV1RkYxMiV1RkY0RSV1MjUxNCV1RkYwQSV1RkYzMA__,v=8) with extra newlines in the output [Answer] # [Pyth](https://github.com/isaacg1/pyth), ~~23~~ 21 bytes ``` s<R7c.><r1G7"b #"2 9 ``` [Try it online!](https://tio.run/##K6gsyfj/v9gmyDxZz07LpsjQ3VwpSUFZyUjB8v9/AA "Pyth – Try It Online") ``` s<R7c.><r1G7"b #"2 9 Implicit: G=lowercase alphabet r1G Convert G to upper case < 7 First 7 characters * "b #" Cartesian product with "b #" .> 2 Rotate the above 2 places to the right c 9 Chop into pieces of length 9 <R7 Trim each to length 7 s Flatten, implicit print ``` Edit: Partial rewrite to save 2 bytes, previous version: `s%2c<r1G7"b #"xLG"fhoq` [Try it online!](https://tio.run/##K6gsyfj/v1jVKFnLpsjQ3VwpSUFZqcLHXSktI7/w/38A "Pyth – Try It Online") [Answer] # T-SQL, 124 bytes ``` SELECT value+a FROM STRING_SPLIT('A-B-C-D-E-F-G','-') ,(VALUES('b'),(''),('#'))b(a) WHERE value+a NOT IN ('B#','E#','Cb','Fb') ``` Line breaks are for display purposes only. Longer but much more interesting than the trivial version (50 bytes): ``` PRINT'Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#' ``` [Answer] ## [Keg](https://github.com/JonoCode9374/Keg), 43 bytes The string, compressed. ``` AbAA\#BbBCC\#DbDD\#EbEFF\#GbGG\#(:H<[ $]')' ``` [TIO](https://tio.run/##y05N///fMcnRMUbZKcnJ2TlG2SXJxSVG2TXJ1c0tRtk9yd09RlnDysMmWkElVl1T/f9/AA) [Answer] # [Z80Golf](https://github.com/lynn/z80golf), ~~31~~ 29 bytes ``` 00000000: 9d5b dc6d df7f 0603 3e40 d13c cb3a 3008 .[.m....>@.<.:0. 00000010: fff5 7b2f ffaf fff1 20f1 10ec 76 ..{/.... ...v ``` [Try it online!](https://tio.run/##NYwxDsIwEAR7XrEvONY5YocIIf6RKrZzNCA6CvJ4cxFkitFU8xl4fz2sNf4Zca59Ri2xoloyMFKhy4moQQtK1hlKDoBM8hTnepOLjJTD7xD8YWY9Uu7Ma95kAR1dgUtBitgRWY/bw0PerX0B "Z80Golf – Try It Online") Explanation*: Z80Golf is just a simple fantasy machine based on the Z80 8-bit CPU. The program is loaded at memory location `0x0000`, and the rest of the memory is filled with zeroes. Output is done by calling `0x8000`, which will output the value of register A as a character. The program starts with the data that will be processed, 6 bytes in total. Each pair of bytes specifies a note suffix, and a bitmask controlling which of the letters can be combined with this note. To save bytes, the suffix character is inverted (`xor 0xff`) -- this allows the data to be executed as instructions with little side effects, making it possible to remove a jump that skips this data: ``` ; GFEDCBA db 0xff^'b', 0b01011011 ; Ab Bb Db Eb Gb db 0xff^'#', 0b01101101 ; A# C# D# F# G# db 0xff^' ', 0b01111111 ; A B C D E F G skip_data: ``` This is how the CPU decodes this: ``` sbc a, l ; a subtraction with carry on registers we don't care about ld e, e ; put the E register back into itself. This instruction is useless ; but still exists to make the encoding regular. call c, 0xdf6d ; if the carry flag is set, call a function. The carry flag isn't set ; because of the initial register values (all zeroes) when the sbc above ; was executed ld a, a ; as above, put A back into itself. ``` This data is read two bytes at a time into the DE register pair. The stack pointer is used to point to the next element. It starts out at 0, and because the Z80 uses a full, descending stack, any pops will read the next data pair -- all stack operations are 16-bit. The outer loop is implemented with a decrementing counter in the B register, for which the Z80 provides special support in the form of the `djnz` instruction: ``` ld b, 3 process_pair: ... djnz process_pair halt ``` The current letter is held in the A register. Because the increment fits well at the start of the loop, we load one less than the actual start value of `A`: ``` process_pair: ld a, 'A'-1 pop de ; D = bitmask, E = suffix character process_note: inc a srl d ; put the current bitmask bit in the carry flag ; also sets the zero flag if this is the last note in the pair jr nc, skip ; Print the note. Note that we need to preserve the zero flag to check it in the ; loop condition later. rst $38 ; Short encoding of call $0038. ; Because the program is so short, the memory in the 0038..8000 range ; is filled with zeroes, which happens to be the encoding for a no-op. ; The execution will therefore fall-through to the character-print hook. push af ; Save the letter on the stack (which will be just to the left of the ; unprocessed data) to free up A for printing other characters. ; (only 16-bit register pairs can be saved, so we also push the flags) ld a, e cpl ; Undo the inversion used to make the execution fall-through the data. ; Done again each iteration because it takes less bytes to operate ; on the A register. rst $38 ; Print the suffix. xor a ; Standard assembly practice of setting a register to zero by XORing it ; with itself. Saves a byte over a simple `ld a, 0`. rst $38 ; Print a null byte as a separator. pop af ; Restore the current letter from the stack. skip: jr nz, process_note ; If the zero flag (last changed at the srl d) is not set, ; loop once again djnz process_pair halt ``` [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 45 bytes ``` 2↓(,¨⎕A)⎕R', &'⊢'AbAA#BbBCC#DbDD#EbEFF#GbGG#' ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///3@hR22QNnUMrHvVNddQEEkHqOgpq6o@6Fqk7Jjk6KjslOTk7K7skubgouya5urkpuye5uyur/0971DbhUW8fUIOn/6Ou5kPrjR@1TQTygoOcgWSIh2fw/zQA "APL (Dyalog Unicode) – Try It Online") Simple `⎕R`eplace operation, prepending `,` to each element in the string that matches each letter in the `⎕A`lphabet, then dropping the first 2 characters, which are `,`. [Answer] # Brainfuck, 214 Bytes ``` >>>>++++++++[<++++<++++<++++++++++++<++++++++>>>>-]<<+++<++<+.>.>>.<<<.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<+.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<+.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<.>>.>.<<<+ ``` [Try it Online!](https://tio.run/##SypKzMxLK03O/v/fDgi0oSDaBkQiCBiAc0CKdWNtbCBiNtp6dnp2dno2NjZACkbrgRmYUtpEqKGa9v//AQ) [Answer] # [JavaScript (Node.js)](https://nodejs.org), 84 bytes ``` _=>[...'ABCDEFG'].map((n,i)=>`${i%3!=2?n+'b,':''}${n}${i%3!=1?`,${n}#`:''}`).join`,` ``` [Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1i5aT09P3dHJ2cXVzV09Vi83sUBDI08nU9PWLkGlOlPVWNHWyD5PWz1JR91KXb1WpTqvFipsaJ@gA@IqJ4AkEjT1svIz8xJ0Ev4n5@cV5@ek6uXkp2ukaWhqWv8HAA "JavaScript (Node.js) – Try It Online") Just returning the string (as shown below) would be shorter by 36 bytes, but where's the fun in that? ``` _=>'Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#' ``` [Answer] # [brainfuck](https://github.com/TryItOnline/brainfuck), ~~255~~ 115 bytes ``` --[----->+<]>-----[<+>>+>+<<-]>>+<<<-[->+++<]>+++[->>>+>+< <<<]>>>>--->+++++++[-<<<<.>.>>.<<<.>>>.<<<.>>.>.<<<+>>>>] ``` [Try it online!](https://tio.run/##SypKzMxLK03O/v9fVzdaFwTstG1i7cCsaBttOzttIN9GN9YORNkAldhpa4MUAEkgGyptAxTQA0KQNj0gD8iyg9J6YIY2WHZQS/3/DwA "brainfuck – Try It Online") [Answer] # [Bash 5](https://www.gnu.org/software/bash/), 42 bytes ``` x=`echo {A..G}{b,,#}`;echo ${x//[BE]#???/} ``` Output: ``` Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G# ``` ]
[Question] [ In base-10, all perfect squares end in \$0\$, \$1\$, \$4\$, \$5\$, \$6\$, or \$9\$. In base-16, all perfect squares end in \$0\$, \$1\$, \$4\$, or \$9\$. Nilknarf describes why this is and how to work this out very well in [this](https://math.stackexchange.com/a/2372342/467325) answer, but I'll also give a brief description here: When squaring a base-10 number, \$N\$, the "ones" digit is not affected by what's in the "tens" digit, or the "hundreds" digit, and so on. Only the "ones" digit in \$N\$ affects the "ones" digit in \$N^2\$, so an easy (but maybe not golfiest) way to find all possible last digits for \$N^2\$ is to find \$n^2 \mod 10\$ for all \$0 \le n < 10\$. Each result is a possible last digit. For base-\$m\$, you could find \$n^2 \mod m\$ for all \$0 \le n < m\$. Write a program which, when given the input \$N\$, outputs all possible last digits for a perfect square in base-\$N\$ (without duplicates). You may assume \$N\$ is greater than \$0\$, and that \$N\$ is small enough that \$N^2\$ won't overflow (If you can test all the way up to \$N^2\$, I'll give you a finite amount of brownie points, but know that the exchange rate of brownie points to real points is infinity to one). Tests: ``` Input -> Output 1 -> 0 2 -> 0,1 10 -> 0,1,5,6,4,9 16 -> 0,1,4,9 31 -> 0,1,2,4,5,7,8,9,10,14,16,18,19,20,25,28 120 -> 0,1,4,9,16,24,25,36,40,49,60,64,76,81,84,96,100,105 ``` this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so standard rules apply! (If you find this too easy, or you want a more in-depth question on the topic, consider this question: [Minimal cover of bases for quadratic residue testing of squareness](https://codegolf.stackexchange.com/questions/35664/minimal-cover-of-bases-for-quadratic-residue-testing-of-squareness)). [Answer] # Google Sheets, ~~52~~ ~~51~~ 47 bytes ``` =ArrayFormula(Join(",",Unique(Mod(Row(A:A)^2,A1 ``` Saved 4 bytes thanks to Taylor Scott Sheets will automatically add 4 closing parentheses to the end of the formula. It doesn't return the results in ascending order but it does return the correct results. [![Results](https://i.stack.imgur.com/lkB07.png)](https://i.stack.imgur.com/lkB07.png) [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes ``` R²%³Q ``` [Try it online!](https://tio.run/##y0rNyan8/z/o0CbVQ5sD////b2wIAA "Jelly – Try It Online") ### Explanation ``` R²%³Q Main link, argument: n R Range from 1 to n ² Square each %³ Mod each by n Q Deduplicate ``` [Answer] # [Swift](https://www.swift.org), ~~47 35~~ 32\* bytes \* -3 thanks to @Alexander. Possibly the first time in history Swift ~~ties~~ beats Python? ``` {m in Set((0..<m).map{$0$0%m})} ``` [Try it online!](http://swift.sandbox.bluemix.net/#/repl/5979f5c2e2406b7625f9fe3f)* --- # Explanation * `(0..<m).map{}` - Iterates through the range `[0...m)` and map the following results: * `$0$0%m` - The square of each integer modulo the base `m`. `Set(...)` - Removes the duplicates. * `m in` - Assigns the base to a variable `m` [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes ``` Lns%ê ``` [Try it online!](https://tio.run/##MzBNTDJM/f/fJ69Y9fCq//8NjQwA "05AB1E – Try It Online") or as a [Test Suite](https://tio.run/##MzBNTDJM/V9TVln53yevWPXwqv86/w25jLgMDbgMzbiMDbkMjQwA "05AB1E – Try It Online") ``` L # Range 1 .. input n # Square each s% # Mod by input ê # Uniquify (also sorts as a bonus) ``` [Answer] # [APL (Dyalog Unicode)](https://www.dyalog.com/), 6 bytes ``` ∪⊢\|⍳×⍳ ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RHHasedS2qedS7@fB0IAEUVDA04AISZiACiI0NAQ "APL (Dyalog Unicode) – Try It Online") Explanation: ``` ∪⊢\|⍳×⍳ ⍳×⍳ ⍝ square every number in range from 1 to ⍵ ⊢\| ⍝ modulo ⍵ ∪ ⍝ unique elements ``` [Answer] # Pyth, 6 bytes ``` {%RQR ``` [Try it online](https://pyth.herokuapp.com/?code=%7B%25RQ%2aR&test_suite=1&test_suite_input=1%0A2%0A10%0A16%0A31%0A120) ### How it works ``` {%RQRdQ implicit variables Q autoinitialized to eval(input()) R over [0, …, Q-1], map d ↦ d times d d %R map d ↦ d modulo Q Q { deduplicate ``` [Answer] # [Japt](https://github.com/ETHproductions/japt/), ~~7~~ 6 bytes ``` Ç²%UÃâ ``` [Test it](http://ethproductions.github.io/japt/?v=1.4.5&code=x7IlVcPi&input=MTIw) 1 byte saved thanks to [Oliver](https://codegolf.stackexchange.com/users/61613/oliver) --- ## Explanation Implicit input of integer `U`. ``` Ç Ã ``` Create an array of integers from `0` to `U-1`, inclusive and pass each though a function. ``` ² ``` Square. ``` %U ``` Modulo `U`. ``` â ``` Get all unique elements in the array and implicitly output the result. [Answer] # [Python 3](https://docs.python.org/3/), ~~40~~ ~~39~~ 37 bytes -1 byte thanks to Mr. Xcoder. -2 bytes thanks to Business Cat.* ``` lambda m:[{nn%m for n in range(m)}] ``` [Try it online!](https://tio.run/##HYuxCoAgFEV3v@IugYZDFjQEfUk1GGUJ@QpziejbzTpwhwP3HFdYd6qiafu4aTdOGq7p8ptyyhzM7kGwBK9pmbkTzxDDfIYTLTolUUqoIq2WqJKqshgY@yL7Rf@zYUgc3lLghlsh4gs "Python 3 – Try It Online") [Answer] # C#, 63 bytes ``` using System.Linq;m=>new int[m].Select((_,n)=>nn%m).Distinct() ``` [Try it online!](https://tio.run/##lY5BawIxEIXv@RWDICRlDeqhl@3uxapYKggeeihStulYBpIJ7mQrUvztayw99GiP8@Z7j8/JKESOfSfEn7A9ScJQqr@XfSY@lEo534jARn0rSU0iB1@RPmDdEGuTw0XH7oE4Fb@tWfQeXaLIYpfI2JKzqzl3Advm3eMVrWvYQwV9qGrGI@TkNezsFq89rd8KNlWt@Y7NMBj7SJKI88P0WWaWZ6NH@9JSwiyIWlKbne1TzD4DGBSw1xNjTHkbOr0dnYz/wd7/sOqszv0F "C# (Mono) – Try It Online") [Answer] ## JavaScript (ES6), 52 bytes ``` f=(m,k=m,x={})=>k?f(x[kk%m]=m,k-1,x):Object.keys(x) ``` ### Test cases ``` f=(m,k=m,x={})=>k?f(x[kk%m]=m,k-1,x):Object.keys(x) ;[1, 2, 10, 16, 31, 120] .map(m => console.log(m + ' -> ' + f(m))) ``` --- ## Non-recursive version, ~~60~~ 58 bytes Saved 2 bytes thanks to @ThePirateBay* ``` m=>(a=[...Array(m).keys()]).filter(v=>a.some(n=>nn%m==v)) ``` ### Test cases ``` let f = m=>(a=[...Array(m).keys()]).filter(v=>a.some(n=>nn%m==v)) ;[1, 2, 10, 16, 31, 120] .map(m => console.log(m + ' -> ' + f(m))) ``` [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), ~~10~~ 9 bytes ``` >ℕ^₂;?%≜ᶠ ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r/3@5Ry9S4R01N1vaqjzrnPNy24P9/QyOD/1EA "Brachylog – Try It Online") ### Explanation ``` ≜ᶠ Find all numbers satisfying those constraints: ;?% It must be the result of X mod Input where X… ^₂ …is a square… >ℕ …of an integer in [0, …, Input - 1] ``` [Answer] # [Actually](https://github.com/Mego/Seriously), 11 bytes ``` ;╗r⌠²╜@%⌡M╔ ``` [Try it online!](https://tio.run/##ASQA2/9hY3R1YWxsef//O@KVl3LijKDCsuKVnEAl4oyhTeKVlP//MTA "Actually – Try It Online") Explanation: ``` ;╗r⌠²╜@%⌡M╔ ;╗ store a copy of m in register 0 r range(m) ⌠²╜@%⌡M for n in range: ² n*2 ╜@% mod m ╔ remove duplicates ``` [Answer] # [CJam](https://sourceforge.net/p/cjam), 12 bytes ``` {_,_.\f%_&} ``` Anonymous block accepting a number and returning a list. [Try it online!](https://tio.run/##S85KzP1fWPe/Ol4nXk8rJk01Xq32f13Bf2NDAA "CJam – Try It Online") ### Explanation ``` _, Copy n and get the range [0 .. n-1] _.* Multiply each element by itself (square each) \f% Mod each by n _& Deduplicate ``` [Answer] # [Haskell](https://www.haskell.org/), 45 bytes ``` import Data.List f m=nub[n^2`mod`m\|n<-[0..m]] ``` -4 bytes from Anders Kaseorg [Try it online!](https://tio.run/##y0gszk7Nyfn/PzO3IL@oRMElsSRRzyezuIQrTSHXNq80KTovzighNz8lIbcmz0Y32kBPLzc29n9uYmaebUFRZl6JSpqCocF/AA "Haskell – Try It Online") [Answer] # [MATL](https://github.com/lmendo/MATL), ~~6~~ 5 bytes -1 byte thanks to @LuisMendo ``` :UG\u ``` [Try it online!](https://tio.run/##y00syfn/3yrUPab0/39DAwA "MATL – Try It Online") [Answer] # AWK, ~~44~~ ~~43~~ 40 bytes ``` {for(;i++<$0;)if(!a[j=ii%$0]++)print j} ``` I managed to cut off 3 bytes after revisiting this old answer. Step by step: ``` { for(;i++<$0;) For all numbers less of equal to the input... if(!a[j=ii%$0]++) Increments the element j of the array a. j is the last digit of each ii. If the element a[j] is being incremented for the first time (a[j]++ returns 0, so negating it (!a[j]++) returns 1)... print j Prints j. } ``` [Try it online!](https://tio.run/##SyzP/v@/Oi2/SMM6U1vbRsXAWjMzTUMxMTrLNlMrU1XFIFZbW7OgKDOvRCGr9v9/QwMA "AWK – Try It Online") ### Former answer (43 bytes) ``` {for(;i++<$0;)a[ii%$0];for(j in a)print j} ``` Edit: Incrementing the `i` variable during the `for` condition saved one more byte. Step by step: ``` { for(; # starts the loop with no previous statement. i++<$0;) # loops while _i_ is less than the input ($0). # also increments 1 to the _i_ variable after # it is evaluated. a[ii%$0]; # fiat the _ii%$0_ element of the _a_ array! # by only stating _array[element]_, the element exists. # ii%$0 means: i squared (mod $0), i.e., the last digit. for(j in a) # for every element _j_ existing in the _a_ array, print j # prints the element _j_ } ``` [Try it online!](https://tio.run/##SyzP/v@/Oi2/SMM6U1vbRsXAWjMxOlMrU1XFINYaJJylkJmnkKhZUJSZV6KQVfv/v6EBAA "AWK – Try It Online") [Answer] # [Octave](https://www.gnu.org/software/octave/), 27 bytes ``` @(n)unique(mod((1:n).^2,n)) ``` [Try it online!](https://tio.run/##y08uSSxL/Z@mYKugp6f330EjT7M0L7OwNFUjNz9FQ8PQKk9TL85IJ09T83@ahqEmV5qGEYgwNACTZiDSGCxsaGSg@R8A "Octave – Try It Online") [Answer] # Mathematica, 30 bytes ``` Union@Table[Mod[i^2,#],{i,#}]& ``` [Try it online!](https://tio.run/##y00sychMLv6fZvs/NC8zP88hJDEpJzXaNz8lOjPOSEc5Vqc6U0e5Nlbtf0BRZl6JgkOagoOhkcF/AA "Mathics – Try It Online") [Answer] ## JavaScript (ES6), 48 bytes ``` f= n=>[...new Set([...Array(n)].map((_,i)=>ii%n))] ``` ``` <input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o> ``` 43 bytes if returning a `Set` instead of an array is acceptable. [Answer] # [Scala](http://www.scala-lang.org/), ~~32~~ 30 bytes Simple use of the easy tip from OP. ``` (0 to n-1).map(x=>xx%n).toSet ``` [Try it online!](https://tio.run/##K05OzEn8n5@UlZpcouCbmJmnkFpRkpqXUqzgWFBQzcWZkpqmUFxYmliU6pqXopFn5ZlXomkVnFoSDWTE2lb/1zBQKMlXyNM11NTLTSzQqLC1q9CqUM3T1CvJB6r6X8vFVVCUmVeSk6ehZKiga6egpI0wzVBTEyFrhC5rhCxraICh2QBF3gxD3gxZ3hjDcmMU2w2NMC0wAtlQ@x8A "Scala – Try It Online") -2 bytes thanks to @MrXcoder, with priorities (no need for `()` around `` operation) Wondering: is this possible to implicitly tell the compiler to understand things like `(0 to n-1)map(x=>xx%n)toSet` (without having to `import scala.language.postfixOps`)? [Answer] # [Haskell](https://www.haskell.org/), 44 bytes ``` f m=[k\|k<-[0..m],or[mod(n^2)m==k\|n<-[0..m]]] ``` [Try it online!](https://tio.run/##NY2xCsIwGAZf5aM4JPRvaSI4mT6BTo4xSkClkv5JaSsuffdoBbfjbrjOT@He9zk/wMaGJewr29Q1O0qj5XQT8aIlGxOW@C/OZfbPCAP2w/EKcWZULYbXfJrHQ8QGU5feYJQlirUUK/2c@F6khFWkSTWkdrRVpHTj8gc "Haskell – Try It Online") [Answer] # [Perl 6](https://perl6.org), 19 bytes ``` {set (^$_)»²X%$_} ``` [Test it](https://tio.run/##VZDBbsIwDIbveQoLlZEOU5LQhlYVE9edt8MO09DWBgmplIqEaRPipXbdjRfrHECF5RT//@/PlhuzrXS7swY@dVTkbP0Nd8WmNDBr99Y44G/BIjz@Hn9e@sHi0JI9d8Y6mEG1qo3l5EXFZv3Bx6/lcOyrx9rlzAOfKZezpnqvYXhqytlys730jx6AQ7Cqm51DuJ@br8YUzpQQwp4B0Jigk2bQ2dGTIcrZ3xq7q/wifl1@RoXeXNlRaUxTdRm8whB6l6nRcu34oD9K7CD021yyUUMH4WEvZ4cWJPhHpmCguj9KBlJcK0xQY4wZqfpGPSkTeaMo0hKcYooZShJilBplijJDJVAlqFJiKPGP4TMq9u6EpgiMM9QCdYxTjanElCIEEZQWyR8 "Perl 6 – Try It Online") ## Expanded: ``` { # bare block lambda with implicit param ｢$_｣ set # turn the following into a Set (shorter than ｢unique｣) ( ^$_ # a Range upto (and excluding) ｢$_｣ )»² # square each of them (possibly in parallel) X% # cross modulus the squared values by $_ # the input } ``` [Answer] # [Ruby](https://www.ruby-lang.org/), ~~31~~ 30 bytes ``` ->m{(0..m).map{\|n\|nn%m}.uniq} ``` [Try it online!](https://tio.run/##KypNqvxfYBvzX9cut1rDQE8vV1MvN7GguiavJk8rTzW3Vq80L7Ow9n@0oY6RjqGBjqGZjrGhjqGRQaxeamJyRnVNbo1CQWlJsYKScnVurZWCcnVBdG5srVLtfwA "Ruby – Try It Online") [Answer] # [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), 71 bytes ``` > Input >> [1) >> L² >> L%1 >> Each 3 2 >> Each 4 5 >> {6} >> Output 7 ``` [Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTsEzr6C0hMvOTiHaUBNE@RzaBKZUDUGUa2JyhoKxghGcbaJgCmJXm9WCKP/SEqBuBfP/QLb5wy27kMQs/xsaGQAA "Whispers v2 – Try It Online") The TIO Footer simply sorts the output, remove it to see the unsorted set. [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 5 bytes ``` ɾ²$%U ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLJvsKyJCVVIiwiIiwiMTIwIl0=) ``` ɾ # 1...n ² # Each squared % # Modulo... $ # input U # Uniquify the result ``` [Answer] # [Nibbles](http://golfscript.com/nibbles/index.html), 5 bytes ``` `$.,$%^$~@ ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m708LzMpKSe1eMGCpaUlaboWqxJU9HRUVONU6hwgAlDxBRsMuYy4DA24DM24jA25DI0MIOIA) ``` `$ Deduplicate . map , range $ input % mod ^ power $ it ~ 2 @ input ``` [Answer] # [Thunno 2](https://github.com/Thunno/Thunno2), 4 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md) ``` L²ŒU ``` [Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPUwlQzIlQjIlQzUlOTJVJmZvb3Rlcj0maW5wdXQ9MTIwJmZsYWdzPQ==) #### Explanation ``` L²ŒU # Implicit input L # Push [0..input) ² # Square each value Œ # Mod by input U # Uniquify # Implicit output ``` [Answer] # [K (ngn/k)](https://codeberg.org/ngn/k), ~~11~~ 10 bytes ``` {?x!/&=x} ``` [Try it online!](https://ngn.codeberg.page/k#eJxVj9FOwzAMRd/zFUYgBMhd4zRN01bAM098wIS0qkvXaaPd1lR0msa34w4GLC++Prm5savs8DxcPYS3j8NRCJ8dbqb7z11WAcCQz9pVfjeriuU6H/J9vrt/Owo/pRzlG1eVS6BRkBwVxGBAQ3oi5kR+uojOHZABFbOTLCigFBJQrPhWA0mwp7dK5nDpjzg4BaPBEtskKA2JYRWD1aAlpAYMjyREKGrvN10WhmU7d4t2XU06X5QrN5R10SzcpGzfw23vOr9smy6kyMjEhnX7Ecxb1wW+dkG37YudC1wzDxUZG+nr7yIEvDSb3kPwBK+9ZyV4xvEwkILXOWskMS7z22GMBjWmYtzmj55IRP+IYhZjghZTJAYaySBZpBSVRBWjspyh5EXG6FF6vI34F4k6RSPRaEwMWkLLFg6R7JbxF36gcJU=) `&=x` generate a list containing `(0..x; 0..x)` * `/` multiply the two items of the list together `x!` mod the result by `x` * `?` (implicitly) return the distinct last digits [Answer] # [Retina](https://github.com/m-ender/retina), 70 bytes ``` .+ $* ;$`¶$` 1(?=.;(.))\|;1* $1 (1+)(?=((.¶)+\1)?$) D`1¶ ^\|1+ $.& ``` [Try it online!](https://tio.run/##K0otycxL/P9fT5tLRYuLy1ol4dA2lQQuQw17Wz0taw09LU3NGmtDLS4VQy4NQ21NoLAGUPDQNk3tGENNexVNLi6XBEMgnyuuxhBohJ7a//@GBgA "Retina – Try It Online") Warning: Slow for large inputs. Slightly faster 72-byte version: ``` .+ $* $'¶$'; 1(?=.;(.))\|;1* $1 +s`^((1+)¶.)\2 $1 ^1+ D`1¶ ^\|1+ $.& ``` [Try it online!](https://tio.run/##K0otycxL/P9fT5tLRYuLS0X90DYVdWsuQw17Wz0taw09LU3NGmtDLS4VQy7t4oQ4DQ1Dbc1D24DCMUYgsThDbS4ulwRDrUPbuOJqgBwVPbX//40NAQ "Retina – Try It Online") [Answer] # Clojure, 40 bytes ``` #(set(map(fn[x](mod(* x x)%))(range %))) ``` ]
[Question] [ Make a fake loader just like this : ![](https://i.stack.imgur.com/zk5Tr.gif) ## Parameters : * Display `loading` (space) one of these cyclically`-\\|/` (space) (percentage counter from 0-100) then a `%`. * The percentage counter is supposed to increment by 1 every time the display changes. * The time taken by counter to jump to next iteration is random. Any kind of random will do as long as the function/method is capable of generating all random integers having probability > 0 in range `1<= ms <=750` here `ms` being time in milliseconds. * Start at `loading - 0 %`. * End at `loading - 100 %`. * NO INPUT is required. * submit a full program or function or whatever similar. The code that I used : ## C++ ``` #include<stdio.h> #include<time.h> #include<windows.h> int main() { srand(time(NULL)); char a[15],b[]="-\\\|/"; int i=0,j=0,ms; while(j<101) { (i<3)?i++:i=0; wsprintf(a,"loading %c %d ",b[i],j++); printf(a);puts("%"); //This part is to make the output look cool switch(rand()%9) { case 0:ms=1;break; case 1:ms=2;break; case 2:ms=5;break; case 3:ms=10;break; case 4:ms=15;break; case 5:ms=20;break; case 6:ms=25;break; case 7:ms=50;break; case 8:ms=500; } Sleep(ms); //Otherwise this is supposed to be random if(j<101) //like this Sleep(rand()%750+1); system("cls"); } } ``` ## Winner * the code with least bytes wins. [Answer] ## Powershell, ~~71~~ ~~68~~ 65 Bytes Similar to <https://codegolf.stackexchange.com/a/101357/59735> Saved 3 bytes by not being an idiot (left the ... on loading) -3 thanks to VisualMelon changed 750 -> 751 to make sure 750 is included. ``` 0..100\|%{cls;"loading $("\|/-\"[$_%4]) $_ %";sleep -m(random 751)} ``` Explanation: ``` 0..100\|%{ #For range 0-100... cls #Clear Display "loading $("\|/-\"[$_%4]) $_ %" #Display the current string sleep -m(random 750) #Sleep random ms up to 750 } ``` Updated gif [![enter image description here](https://i.stack.imgur.com/pq947.gif)](https://i.stack.imgur.com/pq947.gif) [Answer] # Python 2, ~~119~~ ~~113~~ 112 Bytes I had originally gone with the random amount being `random()/.75`, however the endpoint wouldn't be included. There isn't much difference from this to the other question for the infinite load time except for the randomness and the fact that it actually ends. ``` import time,random as r for i in range(101):print'\rLoading','-\\|/'[i%4],i,'%',;time.sleep(r.randint(1,750)/1e3) ``` thanks to Jonathan Allan for saving 6 bytes, and DJMcMayhem for saving a byte! [Answer] # [MATL](https://github.com/lmendo/MATL), 45 bytes ``` 101:"'loading'O'-\\|/'@)O@qVO37&hD750Yr100/&Xx ``` Example run in the offline compiler: [![enter image description here](https://i.stack.imgur.com/Ea0Ly.gif)](https://i.stack.imgur.com/Ea0Ly.gif) Or try it at [MATL Online!](https://matl.io/?code=101%3A%22%27loading%27O%27-%5C%7C%2F%27%40%29O%40qVO37%26hD750Yr100%2F%26Xx&inputs=&version=19.6.0) ### Explanation ``` 101: % Push array [1 2 ... 101] " % For each 'loading' % Push this string O % Push 0. When converted to char it will be displayed as a space '-\\|/' % Push this sring @) % Modular index into this string with iteration index O % Push 0 @q % Iteration index minus 1 V % Convert to string O % Push 0 37 % Push 37, which is ASCII for '%' &h % Concatenate horizontally into a string, Numbers are converted to char D % Display 750Yr % Random integer with uniform distribution on [1 2 ... 750] 100/ % Divide by 100 &Xx % Pause that many tenths of a second and clear screen % End (implicit) ``` [Answer] ## Batch, 185 bytes ``` @set s=-\!/ @for /l %%i in (0,1,100)do @call:l %%i @exit/b :l @cls @set c=%s:~0,1% @set s=%s:~1%%c% @echo Loading %c:!=^\|% %1 %% @set/aw=%random%%%751 @ping>nul 1.1 -n 1 -w %w% ``` The timing is fairly poor unfortunately, but Batch doesn't have anything better to use than `ping`. [Answer] ## [\><>](http://esolangs.org/wiki/Starfish) (Starfish), ~~86~~ 82 bytes ``` \| v1aoooooooo"loading K"&0"-\\|/" !0x1! + %$<.0+af{od;?)aa&:&Soono$&+1:&" %"{o:} ``` [Try it here!](https://starfish.000webhostapp.com/?script=D4AgbgjAVAhg9gxCBEAbOMAmBLAdgcxAGlkAyABmQFoAdYAemQCgBCcgDwhZAGomBSACQAeAHTkeMAGYBvOJgDcAfgCUsGKQBcpAMoJccQaR4RtyECH7I5mgL5A) ~~This may be able to be golfed more, but I don't see anything super obvious. It sleeps 100ms, 400ms, or 700ms, if this isn't random enough, let me know!~~ Thanks to @TealPelican for saving me 4 bytes and making it much more random! The biggest challenges I found (while still trying to keep it small) were randomness, and actually outputting "loading - 100 %" at the end, instead of just exiting at my nearest convenience :p. [Answer] # [Perl 6](https://perl6.org), 67 bytes ``` for \|<- \ \| />xx Z 0..100 {print "\rloading $_ %";sleep .750.rand} ``` ## Expanded: ``` for # produce a list of all the pairs of values \|<- \ \| /> xx * # a flat infinite list of "clock faces" Z # zipped with 0 .. 100 # all the numbers from 0 to 100 inclusive # &zip / &infix:<Z> stop on the shortest list { # ｢$_｣ will look something like ｢("/", 39)｣ # when it is coerced to a Str, all of its elements # will be coerced to Str, and joined with spaces print "\rloading $_ %"; sleep .750.rand } ``` [Answer] # Javascript (ES6), ~~128~~ ~~118~~ ~~116~~ ~~115~~ ~~112~~ ~~110~~ 109 bytes This seems to work perfectly fine, even with this sketchy source of "random" numbers. ``` (X=_=>setTimeout(i>99\|\|X,1+new Date%750,document.body.innerHTML=`<pre>Loading ${'-\\\|/'[i%4]} ${i++}%`))(i=0) ``` --- Alternative 1, Javascript + HTML, 16 + 84 bytes This one uses an already-existing element to display the remaining content: ``` (X=_=>setTimeout(i>99\|\|X,1+new Date%750,a.innerHTML=`${'-\\\|/'[i%4]} ${i++}%`))(i=0) ``` ``` Loading <a id=a> ``` Alternative 2, 95 bytes If I can assume a tab is opened and that you're pasting this into the console: ``` (X=_=>setTimeout(i>99\|\|X,1+new Date%750,document.title=`Loading ${'-\\\|/'[i%4]} ${i++}%`))(i=0) ``` Instead of showing the HTML, the title of the document will change. --- Thank you to [@user2428118](https://codegolf.stackexchange.com/users/13486/user2428118) for saving 2 bytes! [Answer] # F#, 118 bytes ``` async{let r=System.Random() for i in 0..100 do printf"\rLoading %O %d %%""\|/-\\".[i%4]i;do!Async.Sleep(r.Next(1,750))} ``` In order to run this snippet, pass it into `Async.Start` or `Async.RunSynchronously`. [Answer] # PHP, ~~90~~ ~~83~~ ~~80~~ ~~78~~ ~~77~~ Bytes 77: The closing `;` is not needed. ``` for(;$i<101;usleep(rand(1,75e4)))echo"\rloading ",'-\\|/'[$i%4],' ',$i+++0,'%' ``` 78: While looking for another workaround to get a 0 initially without initializing the variable I came up with this: ``` for(;$i<101;usleep(rand(1,75e4)))echo"\rloading ",'-\\|/'[$i%4],' ',$i+++0,'%'; ``` Changed back to echo to win a few bytes as I only used printf to force-format as int. By incrementing the incremented $i with 0 I get a valid integer. By using single quotes as string delimiter the backslash does not need to be escaped, resulting in another byte freed 80: Moving the increment of $i from the last for-section to the prinf gave me another 3 off. (See comments below) ``` for(;$i<101;usleep(rand(1,75e4)))printf("\rloading %s %d%%","-\\\|/"[$i%4],$i++); ``` 83: Removed init of a variable with the loaderstates. ``` for(;$i<101;usleep(rand(1,75e4)),$i++)printf("\rloading %s %d%%","-\\\|/"[$i%4],$i); ``` 90: I tried removing the init of $i to gain some bytes, as I had to add quite a few to enable the loader animation. printf adds 2 as opposed to echo, but formatting NULL as an integer results in 0. ``` for($l='-\\|/';$i<101;usleep(rand(0,750)1e3),$i++)printf("\rloading %s %d%%",$l[$i%4],$i); ``` [Answer] # Groovy, ~~113~~ 87 bytes -36 bytes thanks to lealand* ``` {p=-1;101.times{print"\rLoading ${"-\\\|/"[p++%4]} $p%";sleep Math.random()750as int}} ``` [Answer] # Bash, ~~162~~ 104 bytes Modification of [Zachary's answer](https://codegolf.stackexchange.com/a/101310) on a related question, with massive improvements by manatwork: ``` s='-\\|/' for x in {0..100};{ printf "\rloading ${s:x%4:1} $x %%" sleep `printf .%03d $[RANDOM%750+1]` } ``` I had to look up how to do [random numbers](http://www.tldp.org/LDP/abs/html/randomvar.html) in bash. ## Ungolfed / Explained ``` s='-\\|/' for x in {0..100} { # \r returns the carriage to the beginning of the current line. # ${s:x%4:1} grabs a substring from s, at index x%4, with a length of 1. printf "\rloading ${s:x%4:1} $x %%" # "$RANDOM is an internal bash function that returns # a pseudorandom integer in the range 0 - 32767." # .%03d is a dot followed by a base-ten number formatted to 3 places, # padded with zeros if needed. # sleep accepts a floating point number to represent milliseconds. sleep `printf .%03d $[RANDOM%750+1]` } ``` [Answer] C#, 170 149 135 Bytes* ``` ()=>{for(int i=0;i++<=100;System.Threading.Thread.Sleep(new Random().Next(1,750)))Console.Write($"\rloading {@"-\\|/"[i % 4]} {i} %");}; ``` Ungolfed: ``` static void l() { for (int i = 0; i <= 100; System.Threading.Thread.Sleep(new Random().Next(1, 750))) Console.Write($"\rloading {@"-\\|/"[i % 4]} {i} %"); } ``` I won't guarantee that every character in this is right, please correct me if there are compilation errors. I had to type the whole thing on my phone so I might have accidentally included some errors... ¯\_(ツ)\_/¯ I hope you guys forgive me that Tested it on my PC, works like a charm and I even saved a whole 20 bytes thanks to pmbanka :) [Answer] # C ~~112~~ 103 bytes Saved 9 bytes thanks to @G. Sliepen. Not very exciting, just a golf of your C++ answer basically. Also not a very exciting random function. I thought about `Sleep(c[i%4])`, or `Sleep(i)` but they're not random at all! ``` #import<windows.h> i;f(){for(;i<101;printf("\rloading %c %d %%","-\\\|/"[i%4],i++),Sleep(rand()%750+1));} ``` Ungolfed: ``` #include <windows.h> int i; void f() { for(;i<101;) { printf("\rloading %c %d %%", "-\\\|/"[i%4], i++); Sleep(rand()%750+1); } } ``` [Answer] ## Mathematica, 133 Bytes ``` Dynamic[If[x<100,x++,,x=0];Row@{"Loading ",StringPart["-\\|/",1+x~Mod~4]," ",x,"%"}, UpdateInterval:>[[email protected]](/cdn-cgi/l/email-protection),TrackedSymbols:>{}] ``` This will run once, assuming x is undefined. `Clear@x` will restart it. 55 characters tied up in verbosity :/ [Answer] ## R - 94 bytes ``` for(i in 0:100){cat('\rLoading',c('-','\\','\|','/')[i%%4+1],i,'%');Sys.sleep(sample(750,1)/1e3)} ``` Really nice that `sample(750,1) == sample(1:750,1)`. [Answer] # HTML + JS (ES6), 16 + 87 = 103 bytes ``` (f=_=>a.innerHTML='\\\|/-'[i++%4]+` ${i<100&&setTimeout(f,Math.random()750),i} %`)(i=0) ``` ``` loading <a id=a> ``` [Answer] # PHP, ~~66~~ 79 bytes ``` for($i=-1;++$i<101;usleep(rand(1,75e4)))echo"\rloading ","-\\\|/"[$i%4]," $i %"; ``` Unfortunately I had to assign $i in order to get it to print '0'. Use like: ``` php -r 'for($i=-1;++$i<101;usleep(rand(1,75e4)))echo"\rloading ","-\\\|/"[$i%4]," $i %";' ``` Edits: thanks to Titus confirming exactly what's allowed with Mukul Kumar we can save 3 bytes with a less restricted range, but not all 9 bytes with an unrestricted range. Thanks also for pointing out that I forgot the cycling character and providing a simple solution to do it. [Answer] # [Noodel](https://tkellehe.github.io/noodel/), noncompeting 40 [bytes](https://tkellehe.github.io/noodel/docs/code_page.html) Just going back through old challenges (as in challenges that were made before Noodel) and competing with Noodel* to find where it is weak. ``` Loading¤”ḋḟƇḣ⁺s¤ṡ⁺Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ€Ḃ ``` If final output does not matter, then can save 2 bytes. ``` Loading¤”ḋḟƇḣ⁺s¤ṡ⁺Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ ``` Noodel pushes the top of the stack to the screen at the end of the program so by adding the `€Ḃ` it prevents that from happening. [Try it:)](https://tkellehe.github.io/noodel/editor.html?code=Loading%C2%A4%E2%80%9D%E1%B8%8B%E1%B8%9F%C6%87%E1%B8%A3%E2%81%BAs%C2%A4%E1%B9%A1%E2%81%BA%E1%B8%B6101%E1%BA%A1%C2%A4%25%C9%B1%E1%B9%A0%C4%96%C2%B2%E2%81%BA%C3%87%E1%B9%9B749%E2%81%BA1%E1%B8%8D%E2%82%AC%E1%B8%82&input=&run=true) ### How It Works ``` Loading¤”ḋḟƇḣ⁺s¤ṡ⁺Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ€Ḃ # Main Noodel script. Loading¤”ḋḟƇḣ⁺s¤ṡ⁺ # Creates the array ["Loading¤-¤", "Loading¤\¤", "Loading¤\|¤", "Loading¤/¤"] Loading¤ # Pushes the string "Loading¤" ”Ƈḟḋḣ # Pushes the array ["-", "\", "\|", "/"] ⁺s # Concats "Loading¤" to each element in the array by prepending. ¤ # Pushes a "¤" onto the stack. ṡ # Pushes ⁺ Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ # Main loop that creates the animation. Ḷ101 # Loop the following code 101 times. ạ # Pushes on a copy of the next animation element from the array. ¤% # Pushes the string "¤%" ɱ # Pushes on the current count of the number of times that have looped (zero based). Ṡ # Swaps the two items at the bottom of the stack. Ė # Pushes the item at the bottom of the stack to the top (which will be the string selected from the array). ²⁺ # Concat twice appending the loop count then the string "¤%" to the string selected from the array. Ç # Pops the string off of the stack, clears the screen, then prints the string. ṛ749 # Randomly generate an integer from 0 to 749. ⁺1 # Increment the random number producing a random number from 1 - 750. ḍ # Pop off the stack and delay for that number of milliseconds. €Ḃ # Ends the loop and prevents anything else being displayed. € # Ends the loop (new line could be used as well) Ḃ # Destroys the current stack therein, nothing gets pushed to the screen at the end of the program. ``` ``` <div id="noodel" code="Loading¤”ḋḟƇḣ⁺s¤ṡ⁺Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ€Ḃ" input="" cols="14" rows="2"></div> <script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script> <script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script> ``` [Answer] ## C ~~126~~ 121 bytes ``` f(){i=0;char c[]="/-\\\|";for(;i<101;i++){printf("\rloading %c %d %% ",c[i%4],i);fflush(stdout);usleep(1000(rand()%75));} ``` Ungolfed version: ``` void f() { int i=0; char c[]="/-\\\|"; for(;i<101;i++) { printf("\rloading %c %d %% ",c[i%4], i); fflush(stdout); usleep(1000(rand()%75)); } } ``` @Carcigenicate @ Mukul Kumar Did not read between the lines there, Thanks! :) [Answer] # MATLAB, 108 bytes ``` function k;for i=0:100;a='-\\|/';pause(rand.749+.001);clc;['loading ' a(mod(i,3)+1) ' ' num2str(i) ' %'] end ``` [Answer] # Octave, ~~122~~ ~~120~~ ~~119~~ 108 bytes I misread the challenge and created an infinite loader that restarted at 0 once it passed 100. Making it into a one time only loader: ``` a='\\|/-';for i=0:100;clc;disp(['Loading ',a(1),' ',num2str(i),' %']);a=a([2:4,1]);pause(0.749rand+.001);end ``` Circulating `a`, `a=a([2:4,1])` was flawr's idea [here](https://codegolf.stackexchange.com/a/101293/31516). Also, saved 2 bytes by skipping the parentheses after `rand` thanks to MattWH. [Answer] # ForceLang, 250 bytes Noncompeting, requires language features which postdate the question ``` def D def D w io.write D l e+"loading"+s D z string.char 8 D s string.char 32 D d datetime.wait 750.mult random.rand() D e z.repeat 24 D n set i 1+i D k s+n+s+"%" set i -1 label 1 w l+"-"+k if i=100 exit() d w l+"\"+k d w l+"\|"+k d w l+"/"+k d goto 1 ``` I should probably fix some bugs related to string literal parsing soon. [Answer] ## Racket 110 bytes ``` (for((i 101))(printf"Loading ~a ~a % ~n"(list-ref'("-" "\\" "\|" "/")(modulo i 4))i)(sleep(/(random 750)1000))) ``` Ungolfed: ``` (define(f) (for ((i 101)) (printf "Loading ~a ~a % ~n" (list-ref '("-" "\\" "\|" "/") (modulo i 4)) i) (sleep (/(random 750)1000)))) ``` Testing: ``` (f) ``` Output: [![enter image description here](https://i.stack.imgur.com/vrjc7.gif)](https://i.stack.imgur.com/vrjc7.gif) (This gif file is showing slower display than actual) [Answer] # 107 75 Ruby -32 thanks to manatwork Normal ``` i=0 (0..100).each{\|c\| system'clear' puts"loading #{'\\|/-'[i=-~i%4]} #{c} %" sleep rand(0.750-0.01)+0.01 } ``` Golfed* ``` 101.times{\|c\|$><<"\rloading #{'-\\|/'[c%4]} #{c} %";sleep rand0.749+0.001} ``` [Answer] ### Python 3, 149 bytes ``` import time,random;f=0;n=0 while n<=100: print("Loading...","\|/-\\"[f],n,"%",end="\r");f+=1 if f>=3:f=0 n+=1 time.sleep(random.uniform(.25,.75)) ``` Similar to Loading... Forever, but I did have to edit my answer from there a lot. [Answer] # TI-Basic, 80 bytes ``` For(I,0,100 For(A,0,randE2 End Text(0,0,"loading "+sub("-\\|/",1+fPart(I/4),1)+" ",I," % End ``` The randomness comes from the `For(` loop (E is scientific E token) and since TI-Basic is interpreted there is also automatically some overhead. Remember that in TI-Basic, lowercase letters and some less common ASCII symbols are two bytes each (so specifically for this program, `l o a d i n g sub( \ \| %` are the two-byte tokens [Answer] # Clojure, 109 bytes ``` (doseq[[c i](map vector(cycle"\\\|/-")(range 101))](print"\rloading"c i\%)(flush)(Thread/sleep(rand-int 751))) ``` Loops over a list of the range of numbers from 0 to 100, zipped with an infinite list of `"\\|/-"` repeating forever. ``` ; (map vector...) is how you zip in Clojure ; All arguments after the first to map are lists. The function is expected to ; take as many arguments as there are lists. vector is var-arg. (doseq [[c i] (map vector (cycle "\\\|/-") (range 101))] ; \r to erase the old line (println "\rloading" c i \%) (Thread/sleep (rand-int 751))) ``` [Answer] # tcl, 116 ``` set i 0;time {lmap c {- \\ \| /} {puts -nonewline stderr "\rloading $c $i%";after [expr int(187rand())]};incr i} 100 ``` Playable in <http://www.tutorialspoint.com/execute_tcl_online.php?PID=0Bw_CjBb95KQMOXoybnVSOVJEU00> [Answer] ## Visual Basic, 371 Bytes ``` module m sub main() Dim s as Object for i as Integer=0 to 100 Select Case new System.Random().next(0,9) Case 0 s=1 Case 1 s=2 Case 2 s=5 Case 3 s=10 Case 4 s=15 Case 5 s=20 Case 6 s=25 Case 7 s=50 Case 8 s=500 End Select Console.SetCursorPosition(0,0) console.write("loading "+"-\\|/"(i mod 4)+" "+i.tostring+" %") system.threading.thread.sleep(s) next end sub end module ``` # Expanded: ``` module m sub main() Dim s as Object for i as Integer=0 to 100 Select Case new System.Random().next(0,9) Case 0 s=1 Case 1 s=2 Case 2 s=5 Case 3 s=10 Case 4 s=15 Case 5 s=20 Case 6 s=25 Case 7 s=50 Case 8 s=500 End Select Console.SetCursorPosition(0,0) console.write("loading " + "-\\|/"(i mod 4) + " " + i.tostring + " %") system.threading.thread.sleep(s) next end sub end module ``` [Answer] # Java 8, 130 bytes ``` ()->{for(int n=0;n<101;Thread.sleep((long)(1+Math.random()750)))System.out.print("\rloading "+"-\\\|/".charAt(n%4)+" "+n+++" %");} ``` Explanation:* ``` ()->{ // Method without parameter nor return-type for(int n=0;n<101; // Loop from 0 to 100 Thread.sleep((long)(1+Math.random()750))) // And sleep randomly 1-750 ms System.out.print( // Print: "\r // Reset to the start of the line loading " // Literal "loading " +"-\\\|/".charAt(n%4)+" " // + the spinner char & a space +n++ // + the number (and increase it by 1) +" %"); // + a space & '%' // End of loop (implicit / single-line body) } // End of method ``` Output gif:* [![enter image description here](https://i.stack.imgur.com/hVAwH.gif)](https://i.stack.imgur.com/hVAwH.gif) ]
[Question] [ Your goal is to create a program that prints itself indefinitely, with a new line after each one. Thus, if your program is a one-liner, it would be repeated on every line of the output. ### Example Program: ``` A ``` Output: ``` A A A ... ``` ### Rules * It must be a complete program, not a snippet or function. * The program should loop forever without stack-overflow or recursion limit errors. * Output is to stdout or closest alternative. * No program input is accepted. * Standard loopholes are disallowed, such as opening the program's file or accessing an external resource. Empty programs are disallowed as a standard loophole. * If your program code ends with a trailing newline, this does not count as the necessary newline between quines, and you must print another. * [codegolf](/questions/tagged/codegolf "show questions tagged 'codegolf'") - Shortest code wins! [Answer] # Fission, 7 bytes ``` '!+!NR" ``` A rather simple modification of [the shortest Fission quine I have found so far](https://codegolf.stackexchange.com/a/50968/8478): I'm simply using the non-destructive `!` instead of `O` and added an `N` for newline. So all in all, here is how it works: control flow starts at the `R` with a right-going atom. `"` toggles string mode, which means everything until the next `"` is printed: in this case `'!+!NR`. That leaves the `"` and the newline to be printed. `'!` sets the atom's mass to 33, `+` increments it to 34 (the character code of `"`) and `!` prints the quote. `N` prints a newline, and `R` is now a no-op in this case, so the loop starts over. The following 7-byte solution also works: ``` "NR'!+! ``` [Answer] # [><>](https://esolangs.org/wiki/Fish), 16 bytes ``` 'ard3o50l2)?.~~ ``` The traditional ><> quine uses too many `o`s, so we use a loop for printing. Before each jump we push 5 and 0 (the coordinates of where to jump to), after which we either jump with `.` if there's still something to print, or pops the top two values with `~~`. (Reverted to the 16 version since I forgot about the stack overflow rule.) [Answer] # CJam, 13 bytes ``` {_o"_g "o1}_g ``` The online interpreter doesn't print anything before the program terminates, so you'll have to test this in the Java interpreter. ## Explanation Finally a generalised CJam quine which doesn't end in `_~`. ``` {_o"_g "o1} ``` This simply pushes a block. `_g` duplicates the block and executes it repeatedly while the top of the stack is truthy (discarding the condition). Now inside the block, the other copy of the block is still on the stack. We duplicate and print it with `_o` and then we print `_g` followed by a newline (the required extra newline between quines) with `"_g\n"o`. Finally we push a `1` onto the stack for the loop to repeat, because unfortunately, blocks aren't truthy (or falsy) in CJam. [Answer] # Python 2, 39 Not a very interesting task in Python as it's trivial to add the while loop to a normal quine. ``` c='while 2:print"c=%r;exec c"%c';exec c ``` [Answer] # Perl 5.10+, ~~40~~ 37 bytes ``` $_=q{say"\$_=q{$_};eval"while 1};eval ``` or (also 37 bytes) ``` $_=q{{say"\$_=q{$_};eval";redo}};eval ``` Invoke with the `-M5.010` or `-E` command line flag, e.g. ``` $ perl -E '$_=q{say"\$_=q{$_};eval"while 1};eval' $_=q{say"\$_=q{$_};eval"while 1};eval $_=q{say"\$_=q{$_};eval"while 1};eval $_=q{say"\$_=q{$_};eval"while 1};eval ... ``` --- Thanks to [Ilmari Karonen](https://codegolf.stackexchange.com/users/3191/ilmari-karonen) for shaving off 3 bytes from my original solution, which was: ``` eval while$_=q{say"eval while\$_=q{$_}"} ``` This, as well as the shorter 37-byte solutions above, are all simple variations of the following quine, which I first saw in one of [Ilmari's other posts](https://codegolf.stackexchange.com/a/37381/31388): ``` $_=q{say"\$_=q{$_};eval"};eval ``` Since all I added in my original solution was a `while` loop, he really deserves most of the credit. :-) [Answer] # [Self-modifying Brainf\\\ (SMBF)](https://esolangs.org/wiki/Self-modifying_Brainfuck), 14 bytes The trailing newline `\n` needs to be a literal, Unix, newline (ASCII code 10). ``` [<[<]>[.>]<.]\n ``` ### Explanation: The code moves the pointer to the far left of its source code, then prints it all, including the newline (twice b/c of the rule). The loop continues. [Answer] # PowerShell, 143 Bytes ``` $d='$d={0}{1}{0}{2}while(1){3}Write($d -f [char]39,$d,"`n",[char]123,[char]125){4}' while(1){Write($d -f [char]39,$d,"`n",[char]123,[char]125)} ``` Based off the Rosetta Code PowerShell [quine](http://rosettacode.org/wiki/Quine#PowerShell), I'm pretty confident this isn't the shortest possible. String replacement formatting in PowerShell is icky for this, because the same delimiters for where to put the replacements `{}` also delimit code blocks `while{}`, so we have to use `[char]` casting, which bloats the code a bunch. [Answer] # Underload, 25 bytes First time I've tried something like this and I'm not sure if follows all the rules as it is a couple of lines. The newline was a bit of a pain. ``` (::a~S:a~^ )::a~S:a~^ ``` [Answer] # [Befunge](http://www.quirkster.com/iano/js/befunge.html), ~~30~~ 20 bytes ``` <,+55,2+98_ #!,#:<" ``` A variation of a popular befunge quine that prints out a newline and pops -1 on the stack if it finishes the line. Unfortunately, Befunge gets verbose when doing things in one line. I tried to remove all of the launchpads (`#`) that i could, but some had to be left in to skip certain commands (like `,`). Changes: 30-20* -> changed the base quine to a custom one I made that uses string input. This way, the branching is a lot easier. Old: ``` :0g,:93`>0-10 #,+$#: #5 _1+> ``` I don't think this is optimal, but it's acceptable for now. [Answer] # K, 30 bytes ``` {f:$_f;{x}{`0:f,"[]\n";1}/1}[] ``` [Answer] ## R, 34 bytes ``` repeat{write(commandArgs()[5],'')} ``` to invoke from the command line as follows: ``` Rscript -e "repeat{write(commandArgs()[5],'')}" ``` [Answer] # ><>, ~~31~~ 29 bytes A simple modification of the traditional [><> quine](http://esolangs.org/wiki/Fish#Quine). ``` "ar00gc0.0+efooooooooooooooo\| ``` To run, paste it [here](http://fishlanguage.com/playground), click 'Submit', then 'Start' (running without animation doesn't work). Feel free to increase the execution speed. [Answer] # Python 2, 48 bytes ``` c='c=\'%s\';while 1:print c%c';while 1:print c%c ``` [Answer] # GolfScript, 16 bytes ``` {.".do ":n\p}.do ``` This ended up looking a lot like [Martin Büttner's CJam entry](https://codegolf.stackexchange.com/a/57621). An interesting feature is that, as it turns out, the shortest way to append `".do"` to the block when it's printed is to assign it to the line terminator `n`. (Of course, we also need to include an actual newline in the string, to replace the one `n` normally contains.) The same string (being truthy in GolfScript) is also left on the stack for the `do` loop to pop off, ensuring that the loop runs forever. [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 16 bytes ``` ∋"∋~kgjẉ₁⊥"gjẉ₁⊥ ``` [You can't quite try it online](https://tio.run/##SypKTM6ozMlPN/r//1FHtxIQ12WnZz3c1fmoqfFR11IlJPb//wA "Brachylog – Try It Online"), but I have verified that it works on my installation. # [Brachylog](https://github.com/JCumin/Brachylog), 18 bytes ``` ∋"∋~kgjw₁⊥~n"gjw₁⊥ ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r//1FHtxIQ12WnZ5U/amp81LW0Lk8Jzv7/HwA "Brachylog – Try It Online") Adapted from the alternate version of [this quine](https://codegolf.stackexchange.com/a/183203/85334), with a backtracking hack I had initially devised for [bogosort](https://codegolf.stackexchange.com/a/182062/85334) of all things. Spends two bytes on `~n` because `ẉ` (the usual means for printing with a trailing newline) hits some odd issues with character encoding on TIO, and an actual newline inserted into the string literal gets printed through `~k` as `\n`. ``` w Print "∋~kgjw₁⊥~n" "∋~kgjw₁⊥~n" ∋ which is an element of the (unused and unconstrained) input ₁ formatted ~n (so that the ~n is replaced with a newline) gj with itself ~k (so that the ~k is replaced with the string in quotes), ⊥ then try again. ``` Since `w₁` takes input as a list `[string to be formatted, formatting arguments]`, wrapping a string in a list with `g` then concatenating it to itself with `j` allows it to be formatted with itself. And since no input is given to the program, the input variable which is implicitly present at the beginning of the program can take on any value, so it can be constrained to one of the infinitely many lists which contain `"∋~kgjw₁⊥~n"` as an element, creating a single choice point to be backtracked to when after printing its source the program hits `⊥`. [Answer] # [Gol><>](https://github.com/Sp3000/Golfish), 10 bytes ``` "r2sslRoao ``` [Try it online!](https://tio.run/##S8/PScsszvj/X6nIqLg4Jyg/Mf//fwA "Gol><> – Try It Online") This can probably be golfed down more [Answer] # Python 3.6, ~~48~~ 43 bytes.* -5 bytes thanks to @Jo King ``` x='while 1:print("x=%r;exec(x)"%x)';exec(x) ``` [Answer] # BASH, 76 bytes Just couldn't resist, especially with PowerShell here :) ``` while true;do a () { echo while true\;do declare -f a echo a\;done } a;done ``` The whitespace is important for an EXACT copy. [Answer] # Javascript (ES6), 64 ``` for(;;(_=>console.log(`for(;;(_=>${arguments.callee})());`))()); ``` Alternatively (also 64) ``` a="for(;;)console.log(`a=${JSON.stringify(a)};eval(a)`)";eval(a) ``` [Answer] # [Microscript](https://esolangs.org/wiki/Microscript), 22 bytes ``` "f1{CqxCanx"f1{CqxCanx ``` Based on the quine from the Esolangs article: `"fCqxah"fCqxah`. Exploits the fact that the language autoappends closing braces as needed, without which this would be two bytes longer. [Answer] ## Batch, 10 (+ 4 for filename length) Not sure if this qualifies for two reasons: * Technically, there may or may not be textual side effects from the Windows command shell, as that depends on how it is configured. * This program invokes itself by name, and I am not sure whether that's prohibited by the rules (specifically the "no opening of program file" rule). It is not opening itself for the purposes of reading and printing out the text; it is simply re-running itself. Further, the file system structure is an integral part of old-school batch scripts (oftentimes even being used to store program state, etc). As such, I am not sure whether this violates the 5th rule or not. The code (for a program named q.bat): ``` echo on&&q ``` [Answer] # [Ceylon](http://ceylon-lang.org/), ~~210~~ 208 bytes Of course this won't win anything... ``` shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}} ``` Original: `shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}` I modified my [Quine from two days ago](https://codegolf.stackexchange.com/a/57935/2338) by adding the `while(true){...}` loop, so I come from the 185 bytes of the plain Quine to 210 (I don't need the trailing new line character anymore). But then I found that a `while(1<2){...}` loop is even two bytes shorter: `shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}` (Ceylon has no `for(;;)` loop like Java, and the braces are also needed for this loop.) [Answer] ## PowerShell, 132 107 Bytes ``` $a='$a={0}{1}{0};for(){2}$a-f[char]39,$a,[char]123,[char]125{3}';for(){$a-f[char]39,$a,[char]123,[char]125} ``` Based off of the Rosetta Quine (Same as @AdmBorkBork) although doesn't use formatting for string replacement... maybe switching to a for loop and using formatting would be best? I'm sure if AdmBorkBork came back they would beat this by a lot :P EDIT Figured out the for loop and replacements, all thanks to my predecessor :) Old attempt: ``` $a='$a=;for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}';for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)} ``` [Answer] # Ruby, ~~41~~ 39 bytes A modification of [one of the Ruby quines found here](https://stackoverflow.com/a/2475931). ``` _="_=%p;loop{puts _%%_}";loop{puts _%_} ``` [Answer] # Java 10, 194 bytes ``` interface M{static void main(String[]a){for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";;)System.out.println(s.format(s,34,s));}} ``` Explanation: [Try it online](https://tio.run/##lctBCsMgEADAr0iIoJAKpb1Jn5BTjqGHxZiyadXgboUS8nabJ7T3mQUKnJbpWStG9nkG50W/EQOjEyXhJAJgVANnjI/xDnqbU1YFsqBb83@RTpI8t85aPXyIfTDpzWY9JL@iInPIAKyou1w70true/M7rfUL) (times out after 60 sec). ``` interface M{ // Class static void main(String[]a){ // Mandatory main-method for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}"; // Unformatted source code ;) // Loop indefinitely System.out.println( // Print with trailing new-line: s.format(s,34,s));}} // The formatted source code ``` [quine](/questions/tagged/quine "show questions tagged 'quine'")-part: * 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 Challenge part: * `for(;;)` is used to loop indefinitely. * `System.out.println(...)` is used to print with trailing new-line [Answer] # [Funky](https://github.com/TehFlaminTaco/Funky), 29 bytes ``` f=@print`f=[f]for)f()`for)f() ``` [Try it online!](https://tio.run/##SyvNy678/z/N1qGgKDOvJCHNNjotNi2/SDNNQzMBSv//DwA "Funky – Try It Online") [Answer] # [RProgN 2](https://github.com/TehFlaminTaco/RProgN-2), 7 bytes ``` «]³]]p: ``` [Try it online!](https://tio.run/##Kyooyk/P0zX6///Q6thDm2NjC6z@/wcA "RProgN 2 – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 14 bytes ``` “;@ṾṄṛ¢”;@ṾṄṛ¢ ``` [Try it online!](https://tio.run/##y0rNyan8//9Rwxxrh4c79z3c2fJw5@xDix41zEXh//8PAA "Jelly – Try It Online") [Answer] # Pyth, 11 bytes ``` #jN B"#jN B ``` [Try it here!](https://tio.run/##K6gsyfj/XznLT8FJCUz@/w8A) [Answer] # [Keg](https://github.com/JonoCode9374/Keg), 16 bytes ``` `{④⑩9⑨,}`{④⑩9⑨,} ``` [Try it online!](https://tio.run/##y05N//8/ofrRxMWPJq60fDRxhU4tKu////@6ybkA "Keg – Try It Online") Ties with most other golfing languages, so I'm happy with that. Pushes the string `{④⑩9⑨,}`, which is then infinitely printed rawly, then nicely followed by a newline infinitely. ]
[Question] [ Consider the [Atbash transformation](https://en.wikipedia.org/wiki/Atbash): ``` A\|B\|C\|D\|E\|F\|G\|H\|I\|J\|K\|L\|M Z\|Y\|X\|W\|V\|U\|T\|S\|R\|Q\|P\|O\|N ``` Where A ⇔ Z and L ⇔ O, e.g. There is an interesting property that some words share. When some strings are translated to their atbash-equivalent, said translation is the original word reversed. I call these Atbash Self Palindromes. As an example, let's translate WIZARD: ``` W → D I → R Z → A A → Z R → I D → W ``` The result is DRAZIW, which is WIZARD reversed. Thus, WIZARD is an atbash self palindrome. Objective Given a string of printable ASCII characters, output or return a truthy value if that string is an atbash self palindrome, and a falsey value otherwise. (This is done through STDIN, closest equivalent, functional input, etc. If your language cannot do any of these, ~~consider choosing a different language~~ you may hardcode the input.) You should do this case-insensitively. If the input is a palindrome and is unaffected by the atbash seqeunce, you should still output true, since a palindrome + itself is a palindrome. This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest program in bytes wins. # Test cases ``` "Input" => true, false "WIZARD" => true "Wizard" => true // case doesn't matter "wIzArD" => true "W I Z A R D" => true "W IZ ARD" => false // the atbash of this is D RA ZIW, which is not a palindrome of W IZ ARD "ABCXYZ" => true // ZYXCBA "345 09%" => false // is not a palindrome "ev" => true // ve "AZGDFSSF IJHSDFIU HFIA" => false "Zyba" => true "-AZ" => false // -ZA is not a reverse of -AZ "Tree vvig" => true // Givv eert "$%%$" => true // palindrome "A$&$z" => true // z$&$A ``` --- ## Leaderboard The Stack Snippet at the bottom of this post generates the catalog from the answers a) as a list of shortest solution per language and b) as an overall leaderboard. To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template: ``` ## Language Name, N bytes ``` where `N` is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance: ``` ## Ruby, <s>104</s> <s>101</s> 96 bytes ``` If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header: ``` ## Perl, 43 + 2 (-p flag) = 45 bytes ``` You can also make the language name a link which will then show up in the snippet: ``` ## [><>](http://esolangs.org/wiki/Fish), 121 bytes ``` ``` var QUESTION_ID=68757,OVERRIDE_USER=44713;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+)(?=[^\n\d<>](?:<(?:s>[^\n<>]<\/s>\|[^\n<>]+>)[^\n\d<>])<\/h\d>)/,OVERRIDE_REG=/^Override\sheader:\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> ``` [Answer] # Pyth, ~~10~~ 9 bytes ``` qJrz0_XJG ``` [Try this fiddle online](http://pyth.herokuapp.com/?code=qJrz0_XJG&input=Wizard&debug=0) or [verify all test cases at once.](http://pyth.herokuapp.com/?code=qJrz0_XJG&input=Wizard&test_suite=1&test_suite_input=WIZARD%0AWizard%0AwIzArD%0AW+I+Z+A+R+D%0AW+IZ+ARD%0AABCXYZ%0A345+09%25%0Aev%0AAZGDFSSF+IJHSDFIU+HFIA%0AZyba%0A-AZ%0ATree+vvig%0A%24%25%25%24&debug=0) ## Explanation ``` qJrz0_XJG rz0 Lowercase input J Store a copy in J _XJG Translate J with the reverse alphabet and reverse q Compare ``` [Answer] # [RX](https://github.com/Adriandmen/RX), ~~9~~ 8 bytes Heavily inspired by Retina, I made this a few days ago. Code: ``` prR`w$rM ``` Explanation: ``` prR`w$rM p # Start pattern r # Reversed lowercase alphabet R # Reversed uppercase alphabet ` # Next pattern w # Equivalent to a-zA-Z_0-9 (word pattern) $ # End pattern and compute regex r # Reverse input M # Change mode to Match mode, compares the atbash string with the reversed string. ``` Try it [here](http://adriandmen.github.io/RX/)! [Answer] # Julia, 96 bytes ``` s->join([get(Dict(zip([u=map(Char,65:90);],reverse(u))),c,c)for c=(S=uppercase(s))])==reverse(S) ``` This is a lambda function that accepts a string and returns a string. To call it, assign it to a variable. Ungolfed: ``` function f(s::AbstractString) # Get all of the uppercase letters A-Z u = map(Char, 65:90) # Create a dictionary for the transformation D = Dict(zip(u, reverse(u))) # Uppercase the input S = uppercase(s) return join([get(D, c, c) for c in S]) == reverse(S) end ``` [Answer] # Bash + Linux utils, 56 ``` tr a-z `printf %s {z..a}`<<<${1,,}\|cmp - <(rev<<<${1,,}) ``` Outputs the empty string for Truthy and something like `- /dev/fd/63 differ: byte 1, line 1` for Falsey. If this is not acceptable then we can add `-s` for an extra 3 bytes and use the standard Unix return codes of 0 for Success (Truthy) and 1 for Failure (Falsey). [Answer] ## [Retina](https://github.com/mbuettner/retina), 44 bytes ``` $ ¬∂$_ T`lL`Ro`.+$ +`(¬∂.)(.) $2$1 i`^(.+)\1$ ``` Prints `1` or `0`. The byte count assumes that the file is encoded as ISO 8859-1. [Try it online!](http://retina.tryitonline.net/#code=JArCtiRfClRgbExgUm9gLiskCitgKMK2LiopKC4pCiQyJDEKaWBeKC4rKVwxJA&input=QUJDIFhZeg) This answer was largely inspired [by DigitalTrauma's sed answer](https://codegolf.stackexchange.com/a/68776/8478) but then again I guess there aren't that many approaches to this challenge in the first place. ### Explanation Whenever you see a `¬∂`, the first thing Retina does after splitting the code into lines is to replace all of those pilcrows with linefeeds. This allows the inclusion of linefeeds for a single byte even though linefeeds are Retina's stage separator. ``` $ ¬∂$_ ``` We start by duplicating the input. We match the end of the input with `$` and insert a linefeed along with the input itself (using `$_`). ``` T`lL`Ro`.+$ ``` A transliteration stage. Let's start with the regex: `.+$`. It matches the second copy of the input (by ensuring the match goes until the end of the string). So only characters in the second copy will be transliterated. The transliteration itself makes use of some very recent features. `l` and `L` are character classes for lower and upper case letters, respectively. `o` refers to the other character set of the transliteration and `R` reverses it. So the two character sets expand to: ``` abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba ``` You'll notice that this swaps the case while doing the Atbash cypher, but we'll do the final comparison case-insensitively anyway. ``` +`(¬∂.)(.) $2$1 ``` Now we reverse the second copy. Unfortunately, Retina doesn't have a convenient way for doing that yet, so we'll have to move one character from the end to the front at a time. This is done by repurposing the linefeed separator as a marker of which part hasn't been reversed yet. We match that part but capture the last character separately. That character goes in front, and the remainder is unchanged. The `+` tells Retina to do this repeatedly until it's no longer possible (because `¬∂` is at the end of the string). ``` i`^(.+)\1$ ``` Finally, we check whether the two strings are the same. The `i` makes the pattern case-insensitive - conveniently, in .NET, this means that backreferences are also case-insensitive. You might notice that we no longer have a separator between the original input and the modified copy. We don't need one though, because they are the same length, and if the string now consists exactly of the same string twice (up to case), then those must be the original and the modified string. If you're wondering what happened to the trailing linefeed that we used as a marker, it's still there, but in many regex flavours `$` also matches before* the last character of the string if that character is a linefeed. Since this stage only consists of a single line, it is taken to be a match stage, which counts the number of matches. If the input is an Atbash palindrome, we'll get exactly one match and the output is `1`. If not, then this regex won't match and the output will be `0`. [Answer] # GNU Sed, 105 ``` s/./\l&/ h y/abcdefghijklmnopqrstuvwxyz/zyxwvutsrqponmlkjihgfedcba/ G : s/$.$\n\1/\n/ t /^.$/{c1 q} c0 ``` Outputs 1 for truthy and 0 for falsey. I tried to do this in Retina, but couldn't figure out how to save the string before Atbash transliteration for reverse comparison with after. Perhaps there is a better way. Sed's `y` transliteration command leaves a lot to be desired. [Answer] # ùîºùïäùïÑùïöùïü, 15 chars / 30 bytes ``` √Ø√æ)ƒ™(·∂ê,·∂ê·¥ô)·¥ô‚âî√Ø√æ) ``` `[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter2.html?eval=false&input=ev&code=%C3%AF%C3%BE%29%C4%AA%28%E1%B6%90%2C%E1%B6%90%E1%B4%99%29%E1%B4%99%E2%89%94%C3%AF%C3%BE%29)` # Explanation ``` √Ø√æ)ƒ™(·∂ê,·∂ê·¥ô)·¥ô‚âî√Ø√æ) // implicit: √Ø=input, ·∂ê=A-Z √Ø√æ) // √Ø.toUpperCase() ƒ™(·∂ê,·∂ê·¥ô)·¥ô // transliterate input from A-Z to Z-A, then reverse ‚âî√Ø√æ) // check if that's still equal to √Ø.toUpperCase() // implicit output ``` [Answer] # Parenthetic, 658 bytes ``` ((()()())(()(((()))))((()()((())))))((()()())(()(((())))()()())((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))((()()())(()(((())))())((()())((()(((())))()()))((()()()())((()(())(()))(()(((())))()())(()((()))))(()((())))((()((()))())((()(())(())())((()(()))(()(((())))()()())((()(()()))((())()()()()()()()()()()()()()()()()()()()()()()()()())((()(()()))((()(()())())((()((()))(()))(()(((())))()())))(()(((())))()()())))))((()(((())))())((()((()))()())(()(((())))()())))))))((()(())(()))((()()()(()))((()()()()())(()(((()))))))((()(((())))())((()()()()())(()(((()))))))) ``` Only works for all caps without whitespace right now, using this modified version of the script so that it supports reading from stdin: ``` #!/usr/bin/env python from collections import defaultdict from itertools import izip import copy import operator import os import sys # map from paren strings to english names # for the predefined symbols (lambda, etc) to_english = defaultdict(lambda:None,\ {'()': 'lambda', '()()': 'define', '(())': 'plus', '(()())': 'minus', '()(())': 'mult', '(())()': 'div', '()()()': 'if', '((()))': 'empty', '()()()()': 'charsof', '()()(())': 'reverse', '()(())()': 'LE', '()(()())': 'not', '(()())()': 'intofchar', '()((()))': 'readline', '((()))()': 'cons', '(())(())': 'equal', '((()))(())': 'car', '((()))()()': 'cdr', '(())(())()': 'char', '(())()(())': 'string'}) # map from english to parenthetic to_scheme = defaultdict(lambda:None) for k,v in to_english.iteritems(): to_scheme[v] = k def Error(errorString = 'unmatched parens', debug_mode = True): if debug_mode: print "Error: " + errorString sys.exit() else: raise Exception('paren mismatch') def bracketsMatch(chars): """Returns False if any parentheses in `chars` are not matched properly. Returns True otherwise. """ level = 0 for p in chars: if p == '(': level += 1 elif p == ')': level -= 1 if level < 0: return False return level == 0 def get_exprs(chars): """Returns a list of character sequences such that for each sequence, the first and last parenthesis match. For example, "(())()()" would be split into ["(())", "()", "()"] """ level = 0 current = [] for p in chars: if p == '(' or p == ')': current.append(p) if p == '(': level += 1 elif p == ')': level -= 1 if level == 0: yield current current = [] ## built-in functions ## def builtin_accumulate(init, accumulate, environment, params): """Helper function that handles common logic for builtin functions. Given an initial value, and a two-parameter function, the environment, and a list of params to reduce, this function will reduce [init] + params using the accumulate function and finally returns the resulting value. """ result = init for param in params: value = interpret(param, environment) try: result = accumulate(result, value) except: Error(str(value) + ' is not the correct type') return result def builtin_plus(environment, params): if len(params) >= 1: return builtin_accumulate(interpret(params[0], environment), operator.add, environment, params[1:]) else: return 0.0 def builtin_minus(environment, params): if len(params) == 0: Error('subtraction requires at least 1 param') return builtin_accumulate(interpret(params[0], environment), operator.sub, environment, params[1:]) def builtin_mult(environment, params): return builtin_accumulate(1.0, operator.mul, environment, params) def builtin_div(environment, params): if len(params) == 0: Error('division requires at least 1 param') return builtin_accumulate(interpret(params[0], environment), operator.div, environment, params[1:]) def builtin_LE(environment, params): return interpret(params[0], environment) <= interpret(params[1], environment) def builtin_lambda(environment, params): bodies = [body for body in params[1:]] params = params[0][1] if len(bodies) == 0: Error("a function had no body") for kind, name in params: if kind != 'symbol': Error('lambda must have only symbols as arguments') def ret(old_environment, arguments): #print bodies try: # create new environment based on args environment = copy.copy(old_environment) for param, arg in izip(params, arguments): environment[param[1]] = interpret(arg, old_environment) # evaluate the function bodies using the new environment return interpret_trees(bodies, environment, False) except: Error("Error evaluating a function") return ret def builtin_equal(environment, params): for param1, param2 in izip(params[:-1], params[1:]): if interpret(param1, environment) != interpret(param2, environment): return False return True def builtin_if(environment, params): if len(params) != 3: Error("'if' takes in exactly 3 params") if interpret(params[0], environment): return interpret(params[1], environment) return interpret(params[2], environment) def builtin_not(environment, params): return False if interpret(params[0], environment) else True def builtin_cons(environment, params): return (interpret(params[0], environment), interpret(params[1], environment)) def builtin_car(environment, params): result = interpret(params[0], environment) if not isinstance(result, tuple): Error("car must only be called on tuples") return result[0] def builtin_cdr(environment, params): result = interpret(params[0], environment) if not isinstance(result, tuple): Error("cdr must only be called on tuples") return result[1] def builtin_char(environment, params): result = interpret(params[0], environment) if result != int(result): Error("char must only be called on integers") return chr(int(result)) def builtin_intofchar(environment, params): result = interpret(params[0], environment) result = ord(result) return result def builtin_string(environment, params): result = '' cur = interpret(params[0], environment) while cur != (): if not isinstance(cur, tuple) or not isinstance(cur[1], tuple): Error("string only works on linked lists") result += cur[0] cur = cur[1] return result def unmakelinked(llist): result = () while llist != (): if not isinstance(llist, tuple) or not isinstance(llist[1], tuple): Error("only works on linked lists") result += (llist[0],) llist = llist[1] return result def makelinked(tup): result = () while tup != (): result = (tup[-1],result) tup = tup[:-1] return result def builtin_reverse(environment, params): result = interpret(params[0], environment) result = makelinked(unmakelinked(result)[::-1]) return result def builtin_charsof(environment, params): result = interpret(params[0], environment) result = makelinked(tuple(result)) return result def builtin_readline(environment, params): result = raw_input() return result # define the default (top-level) scope default_environment = \ {to_scheme['plus']: builtin_plus, to_scheme['minus']: builtin_minus, to_scheme['mult']: builtin_mult, to_scheme['div']: builtin_div, to_scheme['lambda']: builtin_lambda, to_scheme['if']: builtin_if, to_scheme['equal']: builtin_equal, to_scheme['LE']: builtin_LE, to_scheme['not']: builtin_not, to_scheme['empty']: (), to_scheme['car']: builtin_car, to_scheme['cdr']: builtin_cdr, to_scheme['cons']: builtin_cons, to_scheme['char']: builtin_char, to_scheme['string']: builtin_string, to_scheme['readline']: builtin_readline, to_scheme['charsof']: builtin_charsof, to_scheme['reverse']: builtin_reverse, to_scheme['intofchar']: builtin_intofchar} # parse the tokens into an AST def parse(tokens): """Accepts a list of parentheses and returns a list of ASTs. Each AST is a pair (type, value). If type is 'symbol', value will be the paren sequence corresponding to the symbol. If type is 'int', value will be a float that is equal to an int. If type is expr, value will be a list of ASTs. """ # check for errors if not bracketsMatch(tokens): Error('paren mismatch') # to return - a list of exprs exprs = [] for expr in get_exprs(tokens): # check for errors if len(expr) < 2: Error('too few tokens in: ' + ''.join(expr)) elif expr[0] != '(' or expr[-1] != ')': Error('expression found without () as wrapper') # pop off starting and ending ()s expr = expr[1:-1] # symbol if expr[:2] == ['(', ')'] and len(expr) > 2: exprs.append(('symbol', ''.join(expr[2:]))) # integer elif expr[:4] == ['(', '(', ')', ')'] and len(expr) >= 4: exprs.append(('num', expr[4:].count('('))) # expr else: exprs.append(('expr', parse(expr))) return exprs def interpret(tree, environment): """Interpret a single tree (may not be a define) and return the result""" kind, value = tree if kind == 'num': return float(value) elif kind == 'symbol': if value in environment: return environment[value] else: Error('Unresolved symbol - ' + value) elif kind == 'expr': function = interpret(value[0], environment) if not hasattr(function, '__call__'): Error('Symbol "'+value[0]+'" is not a function.') return function(environment, value[1:]) else: Error("Unknown tree kind") def interpret_trees(trees, environment, doprint = True): """Interpret a sequence of trees (may contain defines) and output the result. The trees passed in should be ASTs as returned by parse(). If doprint is true, the post-interpretation value of each tree is printed. """ environment = copy.copy(environment) # hoist define statements (note: trees.sort is stable) #trees.sort(key = lambda x: 0 if x[0] == 'expr' and x[1][0][1] == to_scheme['define'] else 1) ret = None for tree in trees: if tree[0] == 'expr' and tree[1][0][0] == 'symbol' and tree[1][0][1] == to_scheme['define']: try: symbol = tree[1][1] if symbol[0] != 'symbol': Error('first argument to define must be a symbol') symbol = symbol[1] value = tree[1][2] environment[symbol] = interpret(value, environment) except: Error('error evaluating define statement') else: ret = interpret(tree, environment) if doprint: print ret, return ret # read in the code ignoring all characters but '(' and ')' f = open(sys.argv[1],'r') code = [] for line in f.readlines(): code += [c for c in line if c in '()'] # parse and interpret the code. print 'Parenthesis Mismatch' # if an error occured. #try: syntax_trees = parse(code) interpret_trees(syntax_trees, default_environment) #except: # print 'Parenthesis Mismatch' ``` ## Explanation ``` ( define (() ()()) input [[[[]]]] (() (((())))) exec readline ( (() ()((()))) ) ) ( define (() ()()) value of 'A' [[[[]]]] [][][] (() (((())))()()()) 65 ((()) ()()()()()()()()()() ()()()()()()()()()() ()()()()()()()()()() ()()()()()()()()()() ()()()()()()()()()() ()()()()()()()()()() ()()()()()) ) ( define (() ()()) atbash [[[[]]]] [] (() (((())))()) ( lambda (() ()) ( list [[[[]]]] [][] (() (((())))()()) ) ( if (() ()()()) ( equal (() (())(())) list (() (((())))()()) empty (() ((()))) ) then return empty (() ((()))) else ( cons (() ((()))()) ( char (() (())(())()) ( plus (() (())) value of 'A' 65 (() (((())))()()()) ( minus (() (()())) 25 ((()) ()()()()()()()()()() ()()()()()()()()()() ()()()()()) ( minus (() (()())) ( intofchar (() (()())()) ( car (() ((()))(())) list (() (((())))()()) ) ) value of 'A' 65 (() (((())))()()()) ) ) ) ) ( atbash (() (((())))()) ( cdr (() ((()))()()) list (() (((())))()()) ) ) ) ) ) ) ( equals (() (())(())) ( reverse (() ()()(())) ( charsof (() ()()()()) input (() (((())))) ) ) ( atbash (() (((())))()) ( charsof (() ()()()()) input (() (((())))) ) ) ) ``` [Answer] ## Python 3, ~~90~~ 85 bytes ``` s=input().upper() print(s[::-1]==''.join(chr([o,155-o][64<o<91])for o in map(ord,s))) ``` We convert the input to uppercase, and then calculate the Atbashed string by subtracting all ordinals from 155 if they're in the uppercase alphabet range. [Answer] # [Kerf](https://github.com/kevinlawler/kerf), 73 bytes Kerf is a proprietary language in the same general family as APL, J and K. It's possible to write cryptic, compact oneliners and avoid the use of explicit loops: ``` {[s]s:_ s;n:?isnull i:s search\<a:char 97+^26;f:(/a)[i];s match/f[n]:s[n]} ``` However, using the spelled-out aliases for commands instead of the shorthand symbols and using meaningful identifiers makes the program much clearer, and fairly easy to follow even if you aren't familiar with Kerf: ``` def atbash_palindrome(str) { str: tolower str alpha: char range(97, 123) indices: str search mapleft alpha encoded: (reverse alpha)[indices] notfound: which isnull indices return str match reverse encoded[notfound]:str[notfound] } ``` In action: ``` KeRF> p: {[s]s:_ s;n:?isnull i:s search\<a:char 97+^26;f:(/a)[i];s match/f[n]:s[n]}; KeRF> p mapdown ["WIZARD","Wizard","W I Z A R D","ABCXYZ","345 09%","ev","Zyba","$%%$","-AZ"] [1, 1, 1, 1, 0, 1, 1, 1, 0] ``` Kerf probably isn't going to win a ton of codegolf competitions, especially against purpose-built languages, but it might be worth tinkering with if you like the idea of APL-family languages but find the syntax too weird. (Disclaimer: I'm the author of the reference manual for Kerf.) [Answer] # Prolog, 121 bytes ``` a(W):-upcase_atom(W,X),atom_codes(X,C),b(C,Z),!,reverse(Z,C). b([A\|T],[R\|S]):-(A>64,A<91,R is 77-A+78;R=A),(b(T,S);S=[]). ``` This is called with an atom as input, e.g. `a('WIZARD').`. [Answer] # JavaScript (ES6), 91 ``` x=>(x=[...x.toLowerCase()]).every(c=>((v=parseInt(c,36))>9?(45-v).toString(36):c)==x.pop()) ``` TEST* ``` F=x=>(x=[...x.toLowerCase()]).every(c=>((v=parseInt(c,36))>9?(45-v).toString(36):c)==x.pop()) console.log=x=>O.textContent+=x+'\n' ;[ ["WIZARD", true] ,["Wizard", true] // case doesn't matter ,["wIzArD", true] ,["W I Z A R D", true] ,["W IZ ARD", false] // the atbash of this is D RA ZIW, which is not a palindrome of W IZ ARD ,["ABCXYZ", true] // ZYXCBA ,["345 09%", false] // is not a palindrome ,["ev", true] // ve ,["AZGDFSSF IJHSDFIU HFIA", false] ,["Zyba", true] ,["-AZ", false] // -ZA is not a reverse of -AZ ,["Tree vvig", true] // Givv eert ,["$%%$", true] // palindrome ,["$%ZA%$", true] ].forEach(t=>{var i=t[0],x=t[1],r=F(i); console.log(i+' -> '+r+(x==r?' OK':' Fail (expected:'+x+')'))}) ``` ``` <pre id=O></pre> ``` [Answer] # C, ~~101~~ 97 bytes As the question specified ASCII characters, this doesn't handle any other encodings. ``` f(chars){charp=s+strlen(s);while(s&&!(isalpha(--p)?s<64\|\|s+p-27&31:s-p))++s;return s>p;} ``` ## Explanation ``` int f(chars) { char p = s + strlen(s); while (s && !(isalpha(--p) ? s<64\|\|s+p-27&31 : s-p)) ++s; return s > p; } ``` We make a pointer `p` that begins at the end of the string. We then loop, moving both `s` and `p` towards each other `s` reaches the end. This means that every pair of characters will be checked twice, but this saves a couple of bytes compared to stopping as soon as the pointers cross over. At each iteration, we check whether `p` is a letter. If so, check that `s` is in the range of letters (ASCII 64 upward), and that `p` and `s` add up to 27 (mod 32). Non-letters over 64 will fail that test, so we don't need to check `isalpha(s)`. If `p` is not a letter, then we simply test whether it is equal to `s`. In either case, we terminate the loop before `s` and `p` cross over. If `s` and `p` have crossed, then every pair of letters matched correctly, so we return true; otherwise we return false. ## Test program Pass the strings to be tested as command-line arguments. This produces correct output for all the test cases. There is no supplied requirement for the empty string; my implementation returns false for that input. ``` #include <stdio.h> int main(int argc, char argv) { while (++argv) printf("\"%s\" => %s\n", argv, f(argv)?"true":"false"); return 0; } ``` [Answer] # Perl 5, 70 bytes A subroutine: ``` {$"='';reverse(map/[A-Z]/?chr(155-ord):$_,(@_=split'',uc$_[0]))eq"@_"} ``` See it in use: ``` print sub{...}->("W i z a r d") ``` [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 7 bytes ``` ‚á©·∏Çka·∏Çƒø= ``` [Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%E2%87%A9%E1%B8%82ka%E1%B8%82%C4%BF%3D&inputs=wizard&header=&footer=) ``` ‚á© # Lowercase input ·∏Ç # Duplicate and reverse ƒø # Transliterate by... ka·∏Ç # lowercase alphabet and backwards lowercase alphabet = # is it equal to the original? ``` [Answer] # MATL, 23 bytes Uses [current release](https://github.com/lmendo/MATL/releases/tag/7.0.0). ``` jkt"@@2Y2m?_219+]h]tP=A ``` ### Examples ``` >> matl > jkt"@@2Y2m?_219+]h]tP=A > > Tree vvig 1 >> matl > jkt"@@2Y2m?_219+]h]tP=A > > W IZ ARD 0 ``` [Answer] ## CJam, 18 bytes ``` qeu_'[,65>_W%erW%= ``` [Try it online](http://cjam.aditsu.net/#code=qeu_%27%5B%2C65%3E_W%25erW%25%3D&input=Wizard) Works by converting input to uppercase, performing the translation of letters, flips the string, and checks for equality. [Answer] # Japt, ~~30~~ 27 bytes ``` U=Uv)w ¬•Ur"[a-z]"_c +4^31 d ``` [Try it online!](http://ethproductions.github.io/japt?v=master&code=VT1Vdil3IKVVciJbYS16XSJfYyArNF4zMSBk&input=IldpemFyZCI=) ### How it works This is based largely on my [Japt answer](https://codegolf.stackexchange.com/a/68509/42545) on Swap the Alphabet. ``` U=Uv)w ¬•Ur"[a-z]"_c +4^31 d U=Uv) // Set U to U.toLowerCase(). w ¬• // Reverse it, and check if it is equal to: Ur"[a-z]" // Take the input and replace each letter with: _c +4 // Take its char code and add 4. This results in // the string "abc...xyz" // becoming "efg...\|}~". ^31 // XOR the result by 31. This flips its last five 5 bits. // We now have "zyx...cba". d // Convert back from a char code. // Implicit: output last expression ``` [Answer] # Ruby, 56 bytes ``` ->s{s.upcase!;s==s.tr(x=[?A..?Z]'',x.reverse).reverse} ``` It's an anonymous function which takes a string and returns `true` or `false`. It's rather clumsy: In order to save some bytes, it uses the destructive variant of `upcase` (with a `!` after it). `upcase!` unfortunately returns `nil` if nothing is changed (like all numeric input), so some bytes are lost trying to deal with that. Still works tho :) [Answer] # [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 73 bytes / 76 bytes ## Lambda version: (73 bytes) ``` lambda x:(a:=[map(ord,x.upper())])==[[c,155-c][64<c<91]for c in a][::-1] ``` [Try it online!](https://tio.run/##bVFdb4IwFH3nV9w43WApy4y6TCJLqgbtHtVlWsZDhTJI5COl4sefd8XFicmavvScc8@5tzc/yChLO6@5OIX212nDknXAYG/pzLLdx4TleiYCtH/a5jkXumF4hm27ro/avZ7pe@5Ld@AP@m0vzAT4EKfAPNeyzLZ3kryQhZI2PgnFs3EDwUJsuYc0hcRHJoI/BO7AZwWHIONF@iAhYVJyoXQ7csTiWglVKRCggGEGt45AFHpOcdim@DWVEQcm16yIIAvVKy5A3THMMFDyiWAXxX5UQWkmgUHONnEaiCzhlfziqMzxcLRc0Xq7dLUcDbGiOt0ePPdbN7H/GColL@sGZQVhOhk787kD5H06HzvkA6YOwVcvJaGHNavPaWJ6k2VSfM0TvOSiOHevdEq9EJxDWcbf9ehJXJbAuZDVdzZbrWadvGkZN@@bxwvrKfaoAKxp1a4l4tW2z0u2NFAnF3EqdYWjhv3WQKEuDeP0Aw "Python 3.8 (pre-release) ‚Äì Try It Online") ## Code version: (76 bytes) ``` a=[map(ord,input().upper())];print(a==[[c,155-c][64<c<91]for c in a][::-1]) ``` [Try it online!](https://tio.run/##K6gsycjPM7YoKPr/P9E2Wis3sUAjvyhFJzOvoLREQ1OvtKAgtUhDUzPWuqAoM69EI9HWNjo6WcfQ1FQ3OTbazMQm2cbSMDYtv0ghWSEzTyExNtrKStcwVvP//3LPKsciFwA "Python 3.8 (pre-release) ‚Äì Try It Online") ## How it works: * `.upper()` Upper all the char of the input * `a=[map(ord,input().upper())]` In both program we store in `a` the list containing the ascii value of each character. `[... for c in a]` We iterate through this list * `[c,155-c][64<c<91]` If our ascii value is beetween 64 and 91 (if the char is uppercase) we "flip" it. * `a==[...][::-1]` We compare our list with the new formed list reversed ## Note: If we used Python2, we could save 1 byte on the second program because : * -3 bytes: `map()` returns a list so we don't need the `[map()]` syntax anymore -2 bytes (and a little adjustment): `print` doesn't need parenthesis * but +4 bytes because we have to use `raw_input()`instead of `input` [Answer] # [Fig](https://github.com/Seggan/Fig), \$8\log\_{256}(96)\approx\$ 6.585 bytes ``` s$Pcacza ``` [Try it online!](https://fig.fly.dev/#WyJzJFBjYWN6YSIsIlwid2laYXJEXCIiXQ==) ``` s # Are the following equal, ignoring case: # Implicit input $ # Reverse of... a # Lowercased (implicit) input P # Transliterated from ca # Alphabet cz # To reversed alphabet ``` [Answer] ## Python, ~~156~~ 112 bytes ``` a=map(chr,range(65,91)) s=raw_input().upper() print ''.join([dict(zip(a,a[::-1])).get(i,i) for i in s])==s[::-1] ``` Basically, it makes a dictionary of the translation with uppercase letters and the input is capitalized (if everything were lowercase instead, that would add 5 bytes). Then, for each character in the capitalized input, do the translation and append to a list unless the character is not in the alphabet, in which case append the character as is. Join the entire list and compare to the reversed list. Shout-out to @Artyer for posting almost exactly as I was going to post before me. But I need to confirm, this is my work and I did this independently. Based on the Julia answer by Alex A. [Try it here](http://ideone.com/bshNWi) [Answer] # Factor, ~~118~~ 113 bytes This is an anonymous function. ``` [ >upper dup >array [ 1string 65 90 [a,b] [ 1string ] map dup reverse zip >hashtable at ] map "" join reverse = ] ``` I don't know of a shorter way to generate an associative array of the alphabet :c [Answer] # Clojure, 100 bytes ``` (defn x[b](let[a(.toUpperCase b)c(reverse a)](=(map #(char(if(<= 65(int %)90)(- 155(int %))%))a)c))) ``` It should be possible to cut it down to a single anonymous function, cutting around 10 more bytes (of declarations) but I did not find a way yet. [Answer] ## Ruby, 79 77 bytes ``` s=$[0].upcase exit(s==s.reverse.tr('A-Z','ZYXWVUTSRQPONMLKJIHGFEDCBA'))?0:1 ``` Accepts the word to test as a command-line argument. Exits with code 0 (which is truthy to the shell) if the argument is an atbash self palindrome, or with code 1 otherwise. [Answer] ## MATLAB, 61 bytes Not the shortest solution, but still interesting ``` f=@(a)~any(changem(upper(a),90:-1:65,65:90)-fliplr(upper(a))) ``` [Answer] # [Japt](https://github.com/ETHproductions/japt) v2.0a0, 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) Note the unprintable (charcode 155) at the end of the second line. ``` u √î√∏Ur\l_cn# ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&code=dQrU%2bFVyXGxfY24jmw&input=WwoiV0laQVJEIiA9PiB0cnVlCiJXaXphcmQiID0%2bIHRydWUKIndJekFyRCIgPT4gdHJ1ZSAKIlcgSSBaIEEgUiBEIiA9PiB0cnVlCiJXIElaIEFSRCIgPT4gZmFsc2UKIkFCQ1hZWiIgPT4gdHJ1ZQoiMzQ1IDA5JSIgPT4gZmFsc2UKImV2IiA9PiB0cnVlCiJBWkdERlNTRiBJSkhTREZJVSBIRklBIiA9PiBmYWxzZQoiWnliYSIgPT4gdHJ1ZQoiLUFaIiA9PiBmYWxzZQoiVHJlZSB2dmlnIiA9PiB0cnVlCiIkJSUkIiA9PiB0cnVlCiJBJCYkeiIgPT4gdHJ1ZQpdLW1S) [Answer] # [Factor](https://factorcode.org/) + `spelling`, 60 bytes ``` [ >lower dup ALPHABET dup reverse zip substitute reverse = ] ``` [Try it online!](https://tio.run/##TYxBS8QwEIXv/RWP0npTBPWgopC1dhsRke0uasRDtjsuwdrGJO2yFX97LZIW5zTf@2beuyxcbfpVzh/mF5C2UAofZCoqYTWVpaq2sPTVUFWQHbytCwttyLm9NqpyuAyC7wDDhE9csEUSelCdNBsPO94xMxlwCDAs8C8ZgumVzW6eX4SHk9MzHJ/Hnqgdb8Q8SfM8Bb/L8iTlK2QpZ16K/Vr69ZCNRUtDhLZVW89RHEdjWXQQdWHw07/iuqx3ZLBpNNj9Y8Zmt8s/MNSSsYROadhmbZ1yjaMpvsJb/yk1jvpf "Factor ‚Äì Try It Online") ## Explanation: `>lower` Convert to lowercase. Stack: (e.g.) `"wizard"` * `dup` Duplicate. Stack: `"wizard" "wizard"` * `ALPHABET` Place the lowercase alphabet on the stack. Stack: `"wizard" "wizard" "abcdefghijklmnopqrstuvwxyz"` * `dup` Duplicate. Stack: `"wizard" "wizard" "abcdefghijklmnopqrstuvwxyz" "abcdefghijklmnopqrstuvwxyz"` * `reverse` Reverse. Stack: `"wizard" "wizard" "abcdefghijklmnopqrstuvwxyz" "zyxwvutsrqponmlkjihgfedcba"` * `zip` Make an associative array from two sequences. Stack: `"wizard" "wizard" { { 97 122 } { 98 121 } { 99 120 } { 100 119 } { 101 118 } { 102 117 } { 103 116 } { 104 115 } { 105 114 } { 106 113 } { 107 112 } { 108 111 } { 109 110 } { 110 109 } { 111 108 } { 112 107 } { 113 106 } { 114 105 } { 115 104 } { 116 103 } { 117 102 } { 118 101 } { 119 100 } { 120 99 } { 121 98 } { 122 97 } }` * `substitute` Substitute elements in a sequence that have keys in an assoc with their values. Stack: `"wizard" "draziw"` * `reverse` Reverse. Stack: `"wizard" "wizard"` * `=` Are they equal? Stack: `t` [Answer] # [05AB1E](http://github.com/Adriandmen/05AB1E), 8 bytes Code: ``` lDAAR‚Ä°RQ ``` Explanation: ``` l # Lowercase the implicit input D # Duplicate top of the stack AAR # Push the lowercase alphabet (A) and the lowercase alphabet reversed (AR) ‚Ä° # Transliterate a -> b R # Reverse this string Q # Compare with the input string ``` [Try it online!](http://05ab1e.tryitonline.net/#code=bEFBUuKAoVLCuVE&input=d2l6YXJk) ]
[Question] [ Well, Brexit [happened](http://www.bbc.co.uk/news/uk-politics-39431428). And Sky News, being the geniuses they are, have decided to create a countdown on the side of a bus. [![enter image description here](https://i.stack.imgur.com/MCAE7.png)](https://i.stack.imgur.com/MCAE7.png) Your job is to do something similar. The UK leaves the the EU on 31st of March 2019 and you have to create a digital countdown for this that changes every second (with a 0.05 second deviation allowed). ## Input Your program should take absolutely no input. It is banned! ## Output It should output the time until Brexit in the format `ddd:hh:mm:ss`. Leading and trailing newlines are allowed but the display should stay in the same place each time. It should look as though it is actually decreasing in place. As pointed out by @AnthonyPham this doesn't mean printing enough newlines to "clear" the screen, this means that you must actually clear the screen. An output like this isn't allowed: ``` 100:20:10:05 100:20:10:04 ``` Neither is this ``` 100:20:10:05 A thousand newlines 100:20:10:04 ``` as they're on more than one line. You don't have to worry about after Brexit. Your program only has to work up to 31/3/2019 ## Rules * [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are disallowed * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code in bytes wins. * Error messages (although I can't think how) are disallowed * The code should be able to be run in 2 years time (when the UK leaves the EU) and should display the actual time and not start from 730 again (see below) ## Countdown rule The countdown should not be hard-coded and should be able to run at any time before Brexit finishes and still produce the correct result. When a new day is begun the hour should follow the below format ``` 712:00:00:01 712:00:00:00 711:23:59:59 ``` Let me say again, the date Brexit finishes is 31/3/2019 at midnight for convenience (31:3:19 00:00:00 or 31:3:2019 00:00:00 or any other format you want) NB: I think I have everything but I didn't post this in the Sandbox, otherwise the timing could have been off. Feel free to post any suggestions for improvements because it isn't perfect. [Answer] ## JavaScript, ~~134~~ ~~129~~ 113 bytes ``` setInterval("d=-new Date;document.body.innerHTML=`<pre>${d/864e5+17986\|0}:`+new Date(d).toJSON().slice(11,19)",1) ``` Edit: Saved 2 bytes thanks to @Shaggy. Saved 11 bytes thanks to @l4m2. [Answer] # PowerShell, ~~70~~ ~~63~~ ~~55~~ 53 Bytes Excluded double quotes, easy -2 thanks to [@Joey](https://codegolf.stackexchange.com/users/15/joey) ``` for(){cls;(date 31Mar19)-(date)\|% T* ddd\:hh\:mm\:ss} ``` Running this with sleep adds 8 bytes, but the input is mostly invisible if it is run without them, version (63 bytes) with sleep: ``` for(){cls;(date 31/3/19)-(date)\|% T* ddd\:hh\:mm\:ss;sleep 1} ``` `for()` is an infinite loop, and within that loop.. `cls` to clear the screen, get `31/3/19` as a `DateTime` object, and `-` the current date from it, to give the time remaining, then `.ToString()` (`\|% T`) that with the correct format. this will display negative time after brexit. [Answer] # Python 3.6, 146 bytes ``` from datetime import x=datetime while 1:d=x(2019,3,31)-x.now();s=d.seconds;a=s%3600;print(end=f"\r{d.days:03}:{s//3600:02}:{a//60:02}:{s%60:02}") ``` [Answer] # Excel VBA, ~~91~~ ~~84~~ 82 bytes Saved 7 bytes thanks to JoeMalpass pointing out that Excel sees dates as numbers. Saved 2 bytes thanks to JoeMalpass ``` Sub b() Do t=CDec(43555-Now) Cells(1,1)=Int(t) &Format(t,":hh:mm:ss") Loop End Sub ``` Output is to cell `A1` in the active Excel sheet. [Answer] ## C#, ~~173~~ ~~172~~ ~~156~~ ~~150~~ 127 bytes ``` using System;class P{static void Main(){for(;;)Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:d\\:hh\\:mm\\:ss} ");}} ``` Saved 16 bytes thanks to @Bob Saved 6 bytes thanks to @Søren D. Ptæus Formatted version: ``` using System; class P { static void Main() { for (;;) Console.Write($"\r{new DateTime(2019, 3, 31) - DateTime.Now:d\\:hh\\:mm\\:ss} "); } } ``` [Answer] # [AHK](https://autohotkey.com/), 145 Bytes This is not the shortest answer but the result gives a very nice feeling of doom, I think. I originally tried to send the keystrokes `Ctrl`+`A` followed by `DEL` and then whatever the time was but the refresh rate was too slow and it would destroy whatever environment you were in. Instead, then, I went with the GUI. It turned out to take less bytes to completely destroy the window and recreate it than it did to update the control over and over so I went with that. It's a nice effect. ``` Loop{ s=20190331000000 s-=A_Now,S d:=t:=20000101000000 t+=s,S d-=t,D d=-1 FormatTime f,%t%,:HH:mm:ss GUI,Destroy GUI,Add,Text,,%d%%f% GUI,Show } ``` [![I'm gonna sing the doom song!](https://i.stack.imgur.com/PBg3d.gif)](https://i.stack.imgur.com/PBg3d.gif) [Answer] # JavaScript ES5, ~~320~~ ~~319~~ ~~316~~ ~~305~~ ~~295~~ 284 bytes ``` setInterval(function(){a=Math,b=a.floor,c=console,d=Date,e="00",f=new d(2019,2,31),g=a.abs(f-new d)/1e3,h=b(g/86400);g-=86400h;var i=b(g/3600)%24;g-=3600i;var j=b(g/60)%60;g-=60j,c.clear(),c.log((e+h).slice(-3)+":"+(e+i).slice(-2)+":"+(e+j).slice(-2)+":"+(e+a.ceil(g)).slice(-2))}) ``` Thanks to @Fels for referencing `Math`, @dgrcode for referencing `console` ## Un-golfed ``` setInterval(function() { var math = Math, floor = math.floor, c = console, d = Date; var leadings = "00"; // set our brexit date var brexit = new d(2019, 2, 31); // get total seconds between brexit and now var diff = math.abs(brexit - new d()) / 1000; // calculate (and subtract) whole days var days = floor(diff / 86400); diff -= days * 86400; // calculate (and subtract) whole hours var hours = floor(diff / 3600) % 24; diff -= hours * 3600; // calculate (and subtract) whole minutes var minutes = floor(diff / 60) % 60; diff -= minutes * 60; // what's left is seconds // clear the console (because OP said it must print in the same place) c.clear(); // log the countdown, add the leadings and slice to get the correct leadings 0's c.log((leadings + days).slice(-3) + ":" + (leadings + hours).slice(-2) + ":" + (leadings + minutes).slice(-2) + ":" + (leadings + math.ceil(diff)).slice(-2)); }); ``` [Answer] # PHP, 84 bytes ``` for(;$c=DateTime;)echo(new$c('@1553990400'))->diff(new$c)->format("\r%a:%H:%I:%S "); ``` Fairly straightforward. 1553990400 is the timestamp for 31-3-2019 00:00:00 in UTC. It loops infinitely, using DateTime->diff()->format() to output how much time is left. After Brexit has happened, it will start counting up from 0. Commented / more readable version: ``` // Infinite loop, assign DateTime (as a string) to $class for (; $class = DateTime;) { echo (new $class('@1553990400')) // Create a new DateTime object for the brexit date/time. ->diff(new $class) // Caulculate the difference to the current date/time. ->format("\r%a:%H:%I:%S "); // Format it according to the specification, starting with a \r character to move to the start of the line and overwrite the previous output. } ``` [Answer] # CJam, ~~69~~ ~~62~~ ~~59~~ 57 bytes Saved 7 bytes by converting to time format differently Saved 3 bytes thanks to Martin Ender's suggestions Saved 2 bytes by using a carriage return instead of backspaces ``` {15539904e5esm1e3/{60md\}224md\]W%{sYTe[}%':CTe[oDco1}g ``` Can't be run on TIO for obvious reasons. It rewrites the display constantly in an infinite loop so the text kind of flashes in and out (at least in my console), although it only actually updates the time once per second. This 70-byte version only prints once per second: ``` {15539904e5es:Xm1e3/{60md\}224md\]W%{sYTe[}%':CTe[oDco{esXm1e3<}g1}g ``` Explanation ``` { e# Begin a while loop 15539904e5 e# The timestamp on which Brexit will occur es e# The current timestamp m e# Subtract 1e3/ e# Integer divide by 1000, converting to seconds from ms { e# Run this block twice 60md e# Divmod by 60 \ e# Swap top elements }2* e# (end of block) e# This block divmods the timestamp by 60, resulting in e# the remaining minutes and seconds. Then the minutes get e# divmod-ed by 60, to get hours and minutes remaining 24md\ e# Divmod hours remaining by 24 and swap top elements, to get e# the hours left and days left. ] e# Wrap the entire stack in an array W% e# Reverse it since it's currently in the wrong order { e# Apply this block to each element of the array s e# Cast to string (array of digit characters) YTe[ e# Pad to length 2 by adding 0s to the left }% e# (end of map block) ':* e# Join with colons CTe[ e# Pad to length 12 by adding 0s to the left, dealing with the e# special case of the day being 3 digits. o e# Pop and print the resulting string, which is the time Dco e# Print a carriage return, moving the cursor back to the start 1 e# Push 1 }g e# Pop 1, if it's true, repeat (infinite loop) ``` [Answer] # Python 3.5 (118 Bytes) ``` import datetime as d,os d=d.datetime while 1:os.system("cls");e=str(d(2019,3,31)-d.today());print(e[:3]+':'+e[-15:-7]) ``` [Answer] # C#6, 149 bytes Thanks to [Bob](https://codegolf.stackexchange.com/users/4163/bob) for saving 57 bytes! ``` using System;class P{static void Main(){DateTime a,x=new DateTime(2019,3,31);while((a=DateTime.Now)<x)Console.Write($"\r{x-a:ddd\\:hh\\:mm\\:ss}");}} ``` Ungolfed program: ``` using System; class P { static void Main() { DateTime a, x = new DateTime(2019, 3, 31); while ( (a = DateTime.Now) < x) Console.Write($"\r{x-a:ddd\\:hh\\:mm\\:ss}"); } } ``` --- # C#, 210 206 159 bytes Thanks to [Bob](https://codegolf.stackexchange.com/users/4163/bob) for saving another 47 bytes! Thanks to [Martin Smith](https://codegolf.stackexchange.com/users/47524/martin-smith) for saving 4 bytes! ``` using System;class P{static void Main(){DateTime a,x=new DateTime(2019,3,31);while((a=DateTime.Now)<x)Console.Write("\r"+(x-a).ToString(@"ddd\:hh\:mm\:ss"));}} ``` Ungolfed program: ``` using System; class P { static void Main() { DateTime a, x = new DateTime(2019, 3, 31); while ( (a = DateTime.Now) < x) Console.Write("\r" + (x - a).ToString(@"ddd\:hh\:mm\:ss")); } } ``` [Answer] # C, 104 bytes ``` main(x){for(;x=1553990400-time(0);)printf("\n%03d:%02d:%02d:%02d\e[1A",x/86400,x/3600%24,x/60%60,x%60);} ``` ### Breakdown ``` main(x){ for(;x=1553990400-time(0);) // Seconds remaining printf("\n%03d:%02d:%02d:%02d\e[1A",// Move cursor and print: x/86400, // Days x/3600%24, // Hours x/60%60, // Minutes x%60); // Seconds puts("Now we can stop talking about it forever."); // Wishful thinking } ``` Relies on `time` returning number of seconds since 01/01/1970, which is the case for me (using Clang/GCC on macOS) and should be the case for most UNIX stuff. Uses ~~bash~~ terminal escape sequences to move the cursor around (`<esc>[1A` moves the cursor up 1 line). It would be nicer to be able to simply use `\r`, but `printf` won't flush until it sees a newline, and flushing it manually takes a lot more. Probably the most CPU intensive countdown I've ever seen. Runs in a hot loop to make sure it's always as accurate as can be. If run after the deadline, it will produce some pretty weird stuff (negatives everywhere!) [Answer] # C#, 128 127 Bytes ``` using System;class P{static void Main(){for(;;)Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}");}} ``` Ungolfed code: ``` using System; class P { static void Main() { for(;;) Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}"); } } ``` I would not have figured out the \r trick without help from the other C# answers here. For anyone looking for further improvement, you can also put the Write() expression inside the for loop. Seems like I should be able to save a byte somehow here, because that saves me the semi-colon for that statement, but it works out to the same number because you can't have a fully empty body: ``` using System;class P{static void Main(){for(;;Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}"));}} ``` [Answer] ## Ruby (83 bytes) ``` loop{h=431664-Time.now.to_r/3600;$><<['%02d']4?:%[h/24,h%24,h%160,h3600%60]+?\r} ``` ## Ungolfed ``` loop do seconds = 1553990400 - Time.now.to_r print (["%02d"] * 4).join(':') % [ seconds / 24 / 60 / 60 , seconds / 60 / 60 % 24, seconds / 60 % 60, seconds % 60, ] + "\r" end ``` Basically one of the Python submissions, with some improvements. We just emit an "\r" to go beginning of the string before re-rendering. And for the string format of `"%03d:%02d:%02d:%02d"`, we really don't care about the width on the first specifier… so we can just do `"%02d"4`, and emit a backspace and a space to clear the extra unnecessary colon. Also, I found a two-character shorter `print`: `$><<`. `$>` is a shorthand global for `$defout`, which is the output stream for `print` and `printf` and defaults to `STDOUT`. `IO#<<` writes the right hand side of it to the stream. How is that two characters shorter? Well, I can now omit the space that led before the parenthesis wrapping the format string. At this point I genuinely think there is no possible way to shorten this program further in Ruby. Edit: I was wrong. Instead of the first `Time.new(2019,3,31)`, we can just use the raw UNIX time: `1553990400`. Edit 2: I've tried playing around with factoring out minutes, and dividing the UNIX timestamp by that constant, but it doesn't actually wind up saving any bytes. :( Edit 3: Turns out caching `h=3600` actually hurt me by two bytes. Whoops. Edit 4: Saved 3 bytes thanks to @EricDuminill. He used floats, but rationals work without loss of precision! Edit 5: `Array#` as an alias for `Array#join`, with the Ruby `?`-syntax for individual characters! [Answer] ## JavaScript+HTML, 136+7=143 bytes ``` setInterval("d=1553990400-new Date/1e3\|0;w.innerText=[60,60,24,999].map(z=>(q='00'+d%z,d=d/z\|0,q.slice(z<61?-2:-3))).reverse().join`:`") ``` ``` <a id=w ``` [Answer] # C#, 142 bytes ``` using System;class P{static void Main(){a:Console.Write($"\r{(new DateTime(2019,3,31)-DateTime.Now).ToString("d\\:h\\:mm\\:ss ")}");goto a;}} ``` Ungolfed program: ``` using System; class P { static void Main() { a: Console.Write($"\r{(new DateTime(2019, 3, 31) - DateTime.Now).ToString(@"d\:h\:mm\:ss ")}"); goto a; } } ``` [Answer] # Bash + GNU date, 128 bytes 2 bytes shaved off thanks to @muru, and 2 off earlier thanks to @This Guy. ``` C=:%02d;while sleep 1;do D=$[B=3600,A=24B,1553990400-`date +%s`];printf "%03d$C$C$C\r" $[D/A] $[D%A/B] $[D%A%B/60] $[D%60];done ``` ### Ungolfed ``` DAY=86400 HOUR=3600 while sleep 1 ; do DIFF=$[1553990400-`date +%s`] printf "%03d:%02d:%02d:%02d\r" \ $[DIFF/DAY] \ $[DIFF%DAY/HOUR] \ $[DIFF%DAY%HOUR/60] \ $[DIFF%60] done ``` [Answer] # [Phooey](https://github.com/ConorOBrien-Foxx/Phooey), 101 bytes ``` -1(>"`\e`[H"~t/1000;1554004800@%60>&/60@%60>&/60@%24>&/24@@/100{$i}&/10{$i}&$i<(_1":"@/10{$i}&$i<)" "#1) ``` `\e` represents the `ESC` nonprintable, hex `0x1B`. Requires your average Linux terminal (and I believe it may work on Windows with a recent command prompt). Phooey does not support C-style escapes, the bytes must be verbatim or you must use `$cN`. ``` -1 # set sentinel cell ( # do {..} while (cell) (infinite loop) > # move past our sentinel "`\e`[H" # print "clear" ANSI escape code ~t # get current Unix time in milliseconds /1000 # convert to seconds ;1554004800 # 31 Mar 2019 in Unix time - cell @ # Push a copy %60 # Store seconds in the first cell >& # Move to the next cell /60 # Convert to minutes @ # Push a copy %60 # Store minutes in the second cell >&/60@%24> # ya get the point &/24 # get the number of days @@ # begin ugly zero pad code /100{$i} # if intdiv(days, 100) == 0, print 0 &/10{$i} # repeat for tens place &$i # print value < # go to hours place (_1 # do {..} while not -1 (our sentinel) ":" # print ":" @/10{$i} # zero pad &$i # print digit < # go to prev cell ) # loop till sentinel "`\n`" # print new line to flush stdout #1 # wait one second otherwise your terminal will flip out ) # loop forever ``` It does fail miserably for dates after Brexit thanks to signed division lul: ``` -689:0-8:-44:-37 ``` But for dates before Brexit, it is correct. For a version which sets to zero after Brexit, (at the cost of a memory leak and 9 bytes), here you go: ``` -1(>"`\e`[H"~t/1000;1554004800@@&2^{@}&@%60>&/60@%60>&/60@%24>&/24@@/100{$i}&/10{$i}&$i<(_1":"@/10{$i}&$i<)" "#1) ``` Specifically, this code uses some fancy math to check for negative. ``` @@&2^{@}& ``` (Or `@` to patch the memory leak which pops, multiplies by zero, then pushes) It uses the `pow` operator. Specifically, `^` does this: ``` cell = (int64_t)pow(cell, op); ``` So, in equivalent C, this code would be: ``` int64_t positive_or_zero(int64_t val) { int64_t pwr = (int64_t)pow(2, val); if (pwr == 0) { val = pwr; } return val; } ``` `pow` is a function which accepts and returns `double`, however, we downcast this. People who are familiar with how double conversion works will know that infinity converts to `0x8000000000000000`, and fractions between 0 and 1 will be zero. Additionally, \${2}^{x}\$ will always be a number greater than 1 if \$x >= 0\$, and a positive fraction less than 1 if \$x < 0\$. Therefore, if `^` returns 0, we know that \$x\$ is negative. Then, we just push it to the stack. [Answer] # MATL, 45 bytes ``` 737515`tZ'-tkwy-':HH:MM:SS'XOw'%03d'YDwYcDXxT ``` TIO apparently doesn't support clearing the output, but thankfully [MATL Online does](https://matl.io/?code=737515%60tZ%27-tkwy-%27%3AHH%3AMM%3ASS%27XOw%27%2503d%27YDwYcDT%26XxT&inputs=&version=20.9.1)! At 2 bytes more, a bit more CPU-friendly version that does a `pause` (sleep) every second: ``` 737515`tZ'-tkwy-':HH:MM:SS'XOw'%03d'YDwYcDT&XxT ``` [Try this on MATL Online](https://matl.io/?code=737515%60tZ%27-tkwy-%27%3AHH%3AMM%3ASS%27XOw%27%2503d%27YDwYcDT%26XxT&inputs=&version=20.9.1) `737515` is "31st of March 2019" represented MATLAB's default epoch format - number of days from January 0, 0000, optionally including a fractional part to represent the time of day. (I tried to shorten this by calculating it somehow, but its only factors are 5 and another six digit number (147503), and I couldn't figure out a way to do it in less than 6 bytes.) ``` ` % start do-while loop tZ`- % duplicate Brexit date, get current date (& time), subtract tk % duplicate the difference, get the floor of it (this gives number of days left) w % switch stack to bring unfloored difference to top y % duplicate the floored value on top of that - % subtract to get fractional part representing time ':HH:MM:SS'XO % get a datestr (date string) formatted this way w % switch to bring number of days back on top '%03d'YD % format that to take 3 places, with 0 padding if needed wYc % switch to bring time string back on top, concatenate date and time D % display the concatenated result! T&Xx % clear screen after a 1 second pause (the pause is optional, without it the call is `Xx`) T % push True on stack to continue loop ``` [Answer] # PHP, 64 bytes ``` while($d=1553990401-time())echo--$d/86400\|0,date(":H:i:s\r",$d); ``` This will count exactly until `0:00:00:00` and then break/exit. Run with `-r`. -2 bytes if I wouldn´t have to print the 0. [Answer] # RPL, 83 78 bytes Assuming your HP48, or similar, is setup with correct (UK) time and date, mm/dd date format, and 24h time format: ``` WHILE 1REPEAT DATE 3.302019DDAYS":"1.1 24TIME HMS- TSTR 15 23SUB + + 1DISP END ``` I was surprised to be able to save 2 bytes by removing spaces around `":"`. 1.1 is the shortest valid date, later dumped by `SUB`. Be careful with emulators, the time may run faster or slower (or not at all) than your wall clock. With a real HP, you can stop this program by pressing the ON key … or wait for empty batteries. [Answer] # [SlimSharp](https://github.com/jcoehoorn/SlimSharp), 56 bytes ``` for(;;)P($"{TP("2019-3-31")-T.Now:ddd\\:hh\\:mm\\:ss}"); ``` [Answer] # PHP, 102 95 90 bytes Saved 7 bytes thanks to @TheLethalCoder & by not factoring Saved another 5 bytes by concatenating ``` <? $b=1553990400-time();echo floor($b/$d=86400).date(':H:i:s', $b%$d);header('Refresh:1'); ``` This is my first golf, so I'm probably missing quite a few tricks, but here you are regardless. As for @chocochaos' PHP answer that would otherwise trump this, I believe it is flawed for reasons I have explained in my comments, but as I'm new here I might be wrong. Or I'm just a newbie :) [Answer] # [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 78 bytes ``` BEGIN{for(;v=1552953600-systime();printf"\r%d:%s",v/86400,strftime("%T",v)){}} ``` [Try it online!](https://tio.run/nexus/awk#@@/k6u7pV52WX6RhXWZraGpqZGlqbGZgoFtcWVySmZuqoWldUJSZV5KmFFOkmmKlWqykU6ZvYWZiYKBTXFKUBlaipBoCFNXUrK6t/f8fAA "AWK – TIO Nexus") Was longer before I realized I could precalculate the end time. Sometimes it pays to be a bit late to the game and get ideas from others. FYI, the TIO link doesn't work very well, since it doesn't implement `\r` properly. [Answer] # F#, 142 bytes ``` open System let f= let t=DateTime(2019,3,31) while DateTime.Now<=t do Console.Clear();t-DateTime.Now\|>printf"%O";Threading.Thread.Sleep 1000 ``` I grew up in Ireland about half a kilometre from the border. Apart from a "Welcome to Fermanagh" sign and the road markings changing you wouldn't know you'd entered another country. Used to cross it twice on the way to school. [Answer] # c, gcc 114 bytes ``` main(s){system("clear");if(s=1553900399-time(0)){printf("%d:%d:%d:%d\n",s/86400,s/3600%24,s/60%60,s%60);main(s);}} ``` Nothing omitted, full program. The program compiles in gcc on Ubuntu. The countdown will not show a long trail of print statements because of the system call to clear and halts when the countdown reaches 0 seconds. # UnGolfed ``` #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <time.h> //Brexit countdown timer int main(){ int sec = 1553900400 - time(0);//seconds remaining until Brexit if(sec){ sleep(1); system("clear"); printf("Brexit Countdown\n"); printf("days Hours Mins Secs\n"); printf("%d: %d: %d: %d\n", sec/86400, sec/3600%24, sec/60%60, sec%60); main(); } } ``` ]
[Question] [ Good Evening Golf Agents, Your mission is on behalf of notorious entertainment giant Eviltronic Arts. As part of their nefarious plan for world enslavement and entertainment, they must sell as many copies of SimStation V as possible. This means that the software must mysteriously stop working, after starting it a few times. Your goal is to write a program that counts the amount of times it has been run. The program must do nothing other then write the integer to stdout. The first time it is run, it should return "1". The next "2" and so on. The program must be able to at least reach the number "14", but there is no required upper limit. However, your program must not write any new files. Accessing itself, or the registry, or even the internet is absolutely OK. But some of our users are suspicious of new files, and will merely overwrite them! The nerve! Defeating the limitations on software they legitimately purchased! The program can not assume a stable interpreter or shell - the program must still work if the entire interpreter nay shell nay computer is restarted between running. As it must be as undetectable as possible, the shortest source code will win. Good luck agents. The entertainment industry is counting on you. [Answer] ## bash script, 39,37,21 18 ``` wc -l<$0;echo>>$0 ``` Short and sweet, my first submission in code golf :) [Answer] # Python, 40, 39, 38 characters Also there is no such upper limit on the runtime: ``` open(__file__,'a').write("+1");print 1 ``` As you can see, the size of the program gradually increases but there was no such restriction in the original problem. I believe, size of the submitted program is all what matters [Answer] ## PHP 48 bytes ``` <?=$n=1 ;fputs(fopen(__FILE__,c),'<?=$n='.++$n); ``` A simple self modifying approach. After running 99 times, it will crash spectacularly. ``` $ php increment.php 1 $ php increment.php 2 $ php increment.php 3 ``` # ⋮ ``` $ php increment.php 97 $ php increment.php 98 $ php increment.php 99 $ php increment.php PHP Parse error: syntax error, unexpected T_STRING, expecting ',' or ';' in increment.php on line 1 ``` [Answer] ## bash script, 37 ``` n=1;echo $n;sed -ie s/$n/$((n+1))/ $0 ``` [Answer] # Ruby: ~~31~~ 21 characters (This is a rewrite of [Abhijit](https://codegolf.stackexchange.com/users/7638/abhijit)'s [Python solution](https://codegolf.stackexchange.com/a/11063). If you like the base idea, upvote his answer, like I did.) ``` open($0,?a)<<"+1";p 1 ``` Sample run: ``` bash-4.2$ ruby increment.rb 1 bash-4.2$ ruby increment.rb 2 bash-4.2$ ruby increment.rb 3 ``` [Answer] # \sh, 14 ``` curl copy.sh/x ``` Using a web service, a different approach than the other existing solutions so far. Limit: The memory of my machine. # JavaScript, 40 ``` alert(localStorage.a=~~localStorage.a+1) ``` Hardly counts as a program, but it's quite long anyways. Does not work in Firefox in a local file. Limit: 2^31. [Answer] # PHP 31 37 characters Self modifying. It counts in unary. Be careful that your text editor doesn't try to be helpful and insert a newline character after the 1. It will only work (properly) in PHP < 5.3.2 because it relies on php to close open file descriptors on shutdown. Or is it acceptable to leak file descriptors? ``` <?fputs(fopen(__FILE__,a),1)?>1 ``` Original version (36 chars), all PHP versions: ``` <?file_put_contents(__FILE__,1,8)?>1 ``` [Answer] ## Python, 50 ``` n=1; print n open(__file__,'r+').write("n="+`n+1`) ``` It uses the same approach as [primo's answer](https://codegolf.stackexchange.com/a/11057/4020) and similarly crashes on the 100th run. [Answer] ## J (58) You need to run this as a script, it will not work from the J command line obviously. ``` echo m=.1 exit(;:^:_1(<":m+1)(<3)};:1!:1[k)1!:2[k=.1{ARGV ``` In J, the tokenizer that the interpreter uses is available as the `;:` function, so if `x` contains J code, `;:x` contains the J tokens, i.e.: ``` ;: 'echo 1 2 3+4 5 6' +----+-----+-+-----+ \|echo\|1 2 3\|+\|4 5 6\| +----+-----+-+-----+ ``` So: `echo m=.1`: set `m` to 1, and write it to the screen * `k=.1{ARGV`: store the 2nd element in `ARGV` (the script name) in `k`. * ...`1!:2[k`: write the following string to the file in `k`: * `;:1!:1[k`: read `k`, the current script, and tokenize * `(<":m+1)(<3)}`: replace the 3rd token by the string representation of `m + 1` * `;:^:_1`: run the tokenizer in reverse, producing a string * `exit`: exit the interpreter (it doesn't do that by itself even if you run a script) [Answer] # PHP, 34 33 chars ``` <?=$_SESSION[A]+=session_start(); ``` Thanks to Tim for the update! My old solution: ``` <?=session_start()+$_SESSION[A]++; ``` The problem is that `$_SESSION[A]` is `""` - empty string - in first iteration, but as `session_start()` returns 1, you can add it and kill two or three flies in one shot! Solution with correct syntax (35 chars): ``` <?=session_start()+$_SESSION[A]++?> ``` [Answer] # Haskell - 36 bytes ``` main=do appendFile"a.hs""+1";print$1 ``` Simply adds `+1` to the end of the source file, which is assumed to be named `a.hs`. The `.hs` extension is mandatory in both ghc and ghci. [Answer] ## TI-Basic, 9 chars ``` :X+1->X:X ``` [Answer] ## Batch - 41 Given the example use case I probably wouldn't assume that this technique is a viable one - It renames the .bat file containing the script - ``` @set/aa=%~n0+1 @echo %a%&@ren %0 %a%.bat ``` Save this to a file called `0.bat` - and call using `0.bat 2>nul`. `2>nul` redirects stderr to nul which is necessary because this script will rename the file containing the script, once it does that cmd can obviously no longer see the script (before it hits EOF) and will return the error `The batch file cannot be found.` Each consecutive call of the script will of course have to be `1.bat 2>nul ... 2.bat 2>nul ... 3.bat 2>nul ... etc ...` [Answer] # mIRC script, 28/22 bytes If put in "aliases" tab, "alias " can be omitted making 22 bytes. ``` alias x inc %i \| echo -ag %i ``` [Answer] ## Python, ~~49~~ 48 characters I realized this will only be 48 chars on Windows due to the `\r\n`. Otherwise it should be 49. ``` n=1 print n;print>>open(__file__,'r+'),"n=",n+1 ``` A cheap ripoff of the method by @grc [Answer] # C, 190 Characters . Works only on Win NT ``` #include <stdio.h> int main(int c,char v[]){ char f[100];sprintf(f,"%s:s",v[0]); if (FILE fp=fopen(f,"r"))fscanf(fp,"%d",&c); FILE fp=fopen(f,"w");printf("%d",c-1);fprintf(fp,"%d",++c); } ``` [Answer] # C#, 142 characters ``` int v=(Microsoft.Win32.Registry.CurrentUser.GetValue("c") as int?)??0+1;Console.Write(v);Microsoft.Win32.Registry.CurrentUser.SetValue("c",v); ``` [Answer] # Tcl, 63 or 73 bytes With some web service it's 73: ``` package require http puts [set [http::geturl http://example.com/c](data)] ``` * modifying itself is 63: ``` proc a a {puts [string le $a]};puts -nonewline [open $argv0 a] a; a a ``` [Answer] # C# - 201 239 234 chars Works for the first 255 times, then wraps over to 0. It won't output anything on the first execution. ``` namespace System.IO{class s{static void Main (string[]a){char f='\|';if(f!='\|'){Console.Write (255);}string p=Reflection.Assembly.GetCallingAssembly().Location;byte[]d=File.ReadAllBytes(p);d[769]++;d[780]++;File.WriteAllBytes(p,d);}}} ``` Save as Main.cs, compile with ``` gmcs Main.cs ``` Tested with gmcs 2.10.8.1 and Mono runtime 2.10.8.1-5ubuntu2 [Answer] # Powershell, 47 Bytes assumes script is named `a.ps1` ``` 0 [int]$n,$t=(gc a.ps1)[0..1];,(++$n),$t>a.ps1 ``` The script will overwrite itself replacing the `0` on the first line with `1`,`2`,`3` and so on. could also save another 8 bytes by replaceing both instances of `a.ps1` with `1` and saving the script as a file named `1` although this is a bit far out for me. Replace second line with this if the file is not saved as 'a.ps1'. ``` [int]$n,$t=(gc($s=$MyInvocation.MyCommand.Name))[0..1];,(++$n),$t>$s ``` --- `0` on first line to initialize the count Linebreak provides the easiest way to split the file in two ``` [int]$n,$t=(gc a.ps1)[0..1] ``` this takes the file 'a.ps1' and reads it in as an array of lines, we then iterate through it with `[0..1]` and set that to the variables `$n` which is cast as `[int]` and `$t` respectively, so that the `0` on the first line becomes `$n` and the 'code' on the second line becomes `$t` ``` ,(++$n),$t>a.ps1 ``` This used the `,1,2` array notation, to create an array of two elements, one being the number stored in `$n` pre-incremented and outputted to stdout by the use of implicit brackets, the second being the second line of text from the file, and then also output it to the file named 'a.ps1' as both input and output are arrays of strings there is minimal formatting required, and almost everything is assumed by the interpreter. [Answer] # [Zsh](https://www.zsh.org/) (no coreutils), 32 bytes ``` a=`<$0` <<<$[$#a/2-15] >>$0<<<: ``` (Note the trailing newline) Uses the length of the script. On each invocation, the last line shown above will append `:` (identical to `true`) and a newline to the script, hence the `/2`. [Try it online!](https://tio.run/##qyrO@G@nUJxclFlQomBjo6Du6u@m/j/RNsFGxSCBy8bGRiVaRTlR30jX0DSWy85OxQAoZPUfqIgrNTkjX0GFKzkjNz9FQbsCagZXUWpBamKJgpGBQlVxBkzwPwA "Zsh – Try It Online") [Answer] ## Rust / cargo-script, 283 bytes Oneliner: ``` use std::fs::File;use std::io::Write;fn main(){let c= 0; let mut v = vec![];::std::io::Read::read_to_end(&mut File::open("w").unwrap(),&mut v);let mut q=&mut File::create("w").unwrap();q.write(&v[..53]);q.write(format!("{:6}",c+1).as_bytes());q.write(&v[59..]);println!("{}",c);} ``` Save as `w` and run with `cargo-script`: ``` $ cargo-script script w Compiling w v0.1.0 (file:///home/vi/.cargo/script-cache/file-w-b4d6541706fabb11) (warnings skipped...) Finished release [optimized] target(s) in 1.47 secs 0 $ cargo-script script w (compilation output skipped) 1 $ cargo-script script w ... 2 $ cargo-script script w 2> /dev/null 3 $ cargo-script script w 2> /dev/null 4 $ cargo-script script w 2> /dev/null 5 $ cargo-script script w 2> /dev/null 6 $ cargo-script script w 2> /dev/null 7 $ cargo-script script w 2> /dev/null 8 $ cargo-script script w 2> /dev/null 9 $ cargo-script script w 2> /dev/null 10 $ cargo-script script w 2> /dev/null 11 ``` Don't iterate too fast or it'll [get stuck](https://github.com/DanielKeep/cargo-script/issues/27). Partially ungolfed: ``` use std::fs::File;use std::io::Write;fn main(){let c= 0; let mut v = vec![]; ::std::io::Read::read_to_end(&mut File::open("w").unwrap(),&mut v); let mut q = &mut File::create("w").unwrap(); q.write(&v[..53]); q.write(format!("{:6}",c+1).as_bytes()); q.write(&v[59..]); println!("{}", c); } ``` Will break after 99999; [Answer] ## GNU sed, 13 + 1(n flag) = 14 bytes ``` $=;$eecho>>s ``` Run: sed -nf s s The assumption is that the source filename is called `s`. A trailing newline is needed after the code, which was counted in the bytes total. Explanation: ``` $= # print the number of lines of the input file $eecho>>s # a shell echo call that appends an empty line to the source file 's' ``` ]
[Question] [ A Cullen Number is any number that is contained in the sequence generated using the formula: C(n) = (n\2^n)+1. ## Your Task: Write a program or function that receives an input and outputs a truthy/falsy value based on whether the input is a Cullen Number. ## Input: A non-negative integer between 0 and 10^9 (inclusive). ## Output: A truthy/falsy value that indicates whether the input is a Cullen Number. ## Test Cases: ``` Input: Output: 1 ---> truthy 3 ---> truthy 5 ---> falsy 9 ---> truthy 12 ---> falsy 25 ---> truthy ``` ## Scoring: This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the lowest score in bytes wins. [Answer] ## x86\_64 machine code ([System V ABI](https://en.wikipedia.org/wiki/X86_calling_conventions#System_V_AMD64_ABI)), 28 27 bytes -1 byte thanks to @Cody Gray, thanks! A constant-time algorithm! ``` _cullen: 0: 0f bd cf bsrl %edi, %ecx 3: 0f bd c1 bsrl %ecx, %eax 6: 89 ca movl %ecx, %edx 8: 29 c2 subl %eax, %edx a: 0f bd c2 bsrl %edx, %eax d: 29 c1 subl %eax, %ecx f: d3 e1 shll %cl, %ecx 11: ff c1 incl %ecx 13: 31 c0 xorl %eax, %eax 15: 39 f9 cmpl %edi, %ecx 17: 0f 94 c0 sete %al 1a: c3 retq ``` Explanation:* Let y an integer and `x=y2^y + 1`. Taking logs, we have `y + log2(y) = log2(x-1)`, thus `y=log2(x-1)-log2(y)`. Plugging back the value of y, we get `y=log2(x-1)-log2(log2(x-1)-log2(y))`. Doing this one more time, we obtain: `y=log2(x-1)-log2[log2(x-1)-log2(log2(x-1)-log2(log2(x-1)-log2(y)))]`. Let us remove the last terms (of the order of `log2(log2(log2(log2(x))))`, this should be safe!), and assume that `x-1≈x`, we obtain: `y≈log2(x)-log2[log2(x)-log2(log2(x))]` Now, letting `f(n) = floor(log2(n))`, it can be verified manually that `y` can be exactly retrieved by: `y=f(x)-f[f(x)-f(f(x))]`, for y < 26, and thus x ⩽ 10^9, as specified by the challenge(1). The algorithm then simply consists of computing y* given x, and verify that x == y\2^y + 1. The trick is that `f(n)` can simply be implemented as the `bsr` instruction (bit-scan reverse), which returns the index of the first 1-bit in n, and `y2^y` as `y << y`. Detailed code: ``` _cullen: ; int cullen(int x) { 0: 0f bd cf bsrl %edi, %ecx ; int fx = f(x); 3: 0f bd c1 bsrl %ecx, %eax ; int ffx = f(f(x)); 6: 89 ca movl %ecx, %edx 8: 29 c2 subl %eax, %edx ; int a = fx - ffx; a: 0f bd c2 bsrl %edx, %eax ; int ffxffx = f(a); d: 29 c1 subl %eax, %ecx ; int y = fx - ffxffx; f: d3 e1 shll %cl, %ecx ; int x_ = y<<y; 11: ff c1 incl %ecx ; x_++; 13: 31 c0 xorl %eax, %eax 15: 39 f9 cmpl %edi, %ecx 17: 0f 94 c0 sete %al 1a: c3 retq ; return (x_ == x); ; } ``` (1)In fact, this equality seems to hold for values of y up to 50000. [Answer] # Pyth, ~~6~~ 5 bytes ``` /mh.< ``` [try it online](https://pyth.herokuapp.com/?code=%2Fmh.<&input=25&debug=0) [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 6 bytes ``` Ḷæ«`i’ ``` [Try it online!](https://tio.run/##y0rNyan8///hjm2Hlx1anZD5qGHm////jUwB "Jelly – Try It Online") Takes input as a command-line argument. If given a Cullen number C(n), outputs n+1 (which is truthy in Jelly, being an nonzero integer; note that we have n≥0 because the input is an integer, and Cullen numbers with negative n are never integers). If given a non-Cullen number, returns 0, which is falsey in Jelly. ## Explanation ``` Ḷæ«`i’ Ḷ Form a range from 0 to (the input minus 1) æ« Left-shift each element in the range by ` itself i’ Look for (the input minus 1) in the resulting array ``` Basically, form an array of Cullen numbers minus one, then look for the input minus one in it. If the input is a Cullen number, we'll find it, otherwise we won't. Note that the array is necessarily long enough to reach to the input, because C(n) is always greater than n. [Answer] ## JavaScript (ES6), ~~37~~ 35 bytes Saved 2 bytes thanks to Neil ``` f=(n,k,x=k<<k^1)=>x<n?f(n,-~k):x==n ``` ### Demo ``` f=(n,k,x=k<<k^1)=>x<n?f(n,-~k):x==n console.log(JSON.stringify([...Array(1000).keys()].filter(n => f(n)))) ``` [Answer] ## Haskell, 28 bytes ``` f n=or[x2^x+1==n\|x<-[0..n]] ``` [Try it online!](https://tio.run/##y0gszk7Nyfn/P00hzza/KLpCyyiuQtvQ1javpsJGN9pATy8vNvZ/bmJmnoKtQkFRZl6JgopCbmKBQppCtLGOpY6hkY6Raex/AA "Haskell – Try It Online") [Answer] # [Ohm](https://github.com/MiningPotatoes/Ohm), 8 bytes ``` @Dº≥Dlε ``` [Try it online!](https://tio.run/##y8/I/f/fweXQLq1HnUtdcs5t/f/fyBQA "Ohm – Try It Online") ``` Implicit input @ Range [1,...,Input] D Duplicate º 2^n each element * Multiply those two array ≥ Increment everything (now I have an array of all Cullen Numbers) Dl Push array length (= get input again, can't get again implicitly or using a function because it would be a string so I'd waste a byte again) ε Is input in array? ``` [Answer] # [PHP](https://php.net/), 43 bytes ``` for(;$argn>$c=1+2*$n$n++;);echo$argn==$c; ``` [Try it online!](https://tio.run/##K8go@G9jX5BRwKWSWJSeZ6tkaGaoZP0/Lb9IwxosYqeSbGuobaSlpZIHRNra1prWqckZ@RDVtirJ1v//AwA "PHP – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes ``` ÝDo¹<å ``` [Try it online!](https://tio.run/##MzBNTDJM/f//8FyXfK1DO20OL/3/39AIAA "05AB1E – Try It Online") Explanation:* ``` ÝDo¹<å Example input: 9. Stack: [9] Ý Range 0-input. Stack: [[0,1,2,3,4,5,6,7,8,9]] D Duplicate. Stack: [[0,1,2,3,4,5,6,7,8,9],[0,1,2,3,4,5,6,7,8,9]] o 2* each item in the list. Stack: [[0,1,2,3,4,5,6,7,8,9], [1,2,4,8,16,32,64,128,256,512]] * Multiply the two lists. Stack: [[0, 2, 8, 24, 64, 160, 384, 896, 2048, 4608]] ¹ Push input again. Stack: [[0, 2, 8, 24, 64, 160, 384, 896, 2048, 4608],9] < Decrement. Stack: [[0, 2, 8, 24, 64, 160, 384, 896, 2048, 4608],8] å Is the first item of the stack in the second item? Stack: [1] Implicit print. ``` [Answer] # [R](https://www.r-project.org/), ~~53~~ ~~51~~ 46 bytes ``` pryr::f(x%in%lapply(0:x,function(y)(y2^y+1))) ``` Anonymous function. Checks if `x` is generated in the sequence C(n) for n in [0,x]. 3 bytes golfed by Giuseppe. [Try it online!](https://tio.run/##K/r/P802rTQvuSQzP0@jQrM6Ma9So8LWNiexoCCnUsPQqkIHLlupqVGpZRRXqW2oqalZy5WmYawJJAyNQKSRKZhtYGRiCGMYaf7//x8A "R – Try It Online") [Answer] ## C, C++, Java, C#, D : 70 bytes Due to the similarities between all these languages, this code works for each ``` int c(int n){for(int i=0;i<30;++i)if((1<<i)i+1==n)return 1;return 0;} ``` [Answer] # Python, 40 bytes ``` lambda n:any(x<<x==n-1for x in range(n)) ``` [Try it online!](https://tio.run/##FcoxCoAgGAbQq3yjgQ0mDUmepBqMysL6DXHQ01uuj/fmeHqSxUJjLrd51s2AlKHM0jgmrakVhw9IuAjBkN0ZNU2p5CpNkmPgEB1H1y8Kb7goMsdhmfvfBw) [Answer] # [Python 2](https://docs.python.org/2/), 36 bytes ``` f=lambda n,i=0:i<<i!=n-1and f(n,i+1) ``` [Try it online!](https://tio.run/##PcuxCsIwFIXhPU9x3CxewUQcDM3aJ3ATh2gTvFBvQ0zBPn0MCE6H/4OT1vKcxdQa3eRf99FDiN3Bct/zxsleexkRtw13uqtxzmCw4HoknAnaEMzpZhVSZilgUih5bd0@3LX5@SUvQSF8HiEV@9fBT@9Qvw "Python 2 – Try It Online") Outputs by not crashing / crashing, as currently allowed by [this meta concensus](https://codegolf.meta.stackexchange.com/a/11908/64121). --- # [Python 2](https://docs.python.org/2/), 42 bytes ``` i=0 n=input()-1 while i<<i<n:i+=1 i<<i>n<c ``` [Try it online!](https://tio.run/##PYzBCsIwEETv@xVLTooIpuLBkHjToyd/oMSFLtRNWFNsvz6mIF6GN7xh8lKGJF2N6UnBGFM5HEACS57KZru38Bl4JGTv2YvjXbCw8kV8rG3@09YBFl1aIs0UcX1rnJWl4EOnVmiOlAve@xddVZO6v7/145vqEc5gO@hOXw "Python 2 – Try It Online") Outputs via exit code [Answer] # [R](https://www.r-project.org/), 26 bytes ``` a=0:26;scan()%in%(1+a2^a) ``` [Try it online!](https://tio.run/##K/r/P9HWwMrIzLo4OTFPQ1M1M09Vw1A7UcsoLlHzv6GCsYKlgqGRgpHpfwA "R – Try It Online") A slightly different approach than the [other R answer](https://codegolf.stackexchange.com/a/127079/67312); reads from `stdin` and since the input is guaranteed to be between 0 and 10^9, we just have to check `n` between 0 and 26. [Answer] # [APL (Dyalog)](https://www.dyalog.com/), 9 bytes To cover the case of n* = 1, it requires `⎕IO←0` which is default on many systems. ``` ⊢∊1+⍳×2⍳ ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/5OB5KOuRY86ugy1H/VuPjzdSAtI/f@ffGiFoYKxgqWCoZGCkSkA "APL (Dyalog Unicode) – Try It Online") `⊢` [is] n* (the argument) `∊` a member of `1` one `+` plus `⍳` the integers 0 … (n-1) `×` times `2` two `` to the power of `⍳` the integers 0 … (n-1) [Answer] # [Python 2](https://docs.python.org/2/), 32 bytes ``` [n<<n\|1for n in range(26)].count ``` [Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPzrPxiavxjAtv0ghTyEzT6EoMS89VcPITDNWLzm/NK/kP5qMoYGBgaYVF2dmmkKaRh6IxVlQlJlXopD3HwA "Python 2 – Try It Online") Creates the list of Cullen numbers up to `10^9`, then counts how many times the input appears in it. Thanks to Vincent for pointing out `n<<n\|1` instead of `(n<<n)+1`, saving 2 bytes. [Answer] # TI-BASIC, 17 bytes ``` max(Ans=seq(X2^X+1,X,0,25 ``` Explanation* ``` seq(X2^X+1,X,0,25 Generate a list of Cullen numbers in the range Ans= Compare the input to each element in the list, returning a list of 0 or 1 max( Take the maximum of the list, which is 1 if any element matched ``` [Answer] # D, 65 bytes This is a port of @HatsuPointerKun's algorithm to D (the original was already D code, but this is with D-specific tricks) ``` T c(T)(T n){for(T i;i<30;++i)if((1<<i)i+1==n)return 1;return 0;} ``` # How? (D specific tricks) D's template system is shorter than C++'s, and can infer types. And D also initializes its variables to the default upon declaration. [Answer] # [Nibbles](http://golfscript.com/nibbles/index.html), 5.5 bytes (11 nibbles) ``` ?.`,$+~^2 ``` Returns 1-based index in list of Cullen numbers (truthy), or zero (falsy) if not a Cullen number. ``` ?.`,$+~^2 # full function ?.`,$+~^2$$$ # (with implicit arguments shown): . # map over `,$ # 0..input-1 # with function: + # add ~ # 1 (default) # to ^2 # 2 to the power of $ # input * $ # multiplied by input ? $ # and get the index of the input in this # (or zero if not found) ``` [![enter image description here](https://i.stack.imgur.com/thOmk.png)](https://i.stack.imgur.com/thOmk.png) [Answer] # [Julia 1.0](http://julialang.org/), 23 bytes ``` ~n=n∈0:n.\|>x->x2^x+1 ``` [Try it online!](https://tio.run/##XY5BasMwEEXX1ikGr@TWDrVLFg3I7TaXCCj1hE4REyGNQYGSdc6ZizhK3RSSWQ1/3vz/v0dHtk3TdGTD59PpZcWLnz41fXrqNum5nXb7AATEENAOjhijrhTksTVswUCUQH6ho3ckmmoom6bpy6pSBbEfJRPehoh6zVKDzTImj5@CQ75sjSkljPJ1KOEd8oawgp11EVWxH2V@P/76qMIHYnGs/2x7mIns@GFjxCBwezFwy1DIw9TmstdSAHOWen0Ulv/CNfyg3h6BtrsHuuU9cAE "Julia 1.0 – Try It Online") [Answer] # Mathematica, 30 bytes ``` MemberQ[(r=Range@#-1)2^r+1,#]& ``` Pure function taking a nonnegative integer as input and returning `True` or `False`. If the input is `n`, then `(r=Range@#-1)` sets the variable `r` to be `{0, 1, ..., n-1}`, and then `r2^r+1` vectorially computes the first `n` Cullen numbers. `MemberQ[...,#]` then checks whether `n` is an element of the list. [Answer] # Mathematica, 32 bytes ``` !Table[x2^x+1,{x,0,#}]~FreeQ~#& ``` [Answer] # Excel VBA, 45 Bytes Anonymous VBE immediate window function that takes input from cell `[A1]` and ouputs to the VBE immediate window Must be run in a clean module or have values for i,j be reset to default value of 0 between runs ``` While j<[A1]:j=(i2 ^ i)+1:i=i+1:Wend:?j=[A1] ``` ### Input / Output I/O as seen in VBE immediate window ``` [A1]=25 While j<[A1]:j=(i2 ^ i)+1:i=i+1:Wend:?j=[A1] True [A1]=1: i=0:j=0 ''# clearing module values While j<[A1]:j=(i2 ^ i)+1:i=i+1:Wend:?j=[A1] True [A1]=5: i=0:j=0 ''# clearing module values While j<[A1]:j=(i2 ^ i)+1:i=i+1:Wend:?j=[A1] False ``` [Answer] ## Swi-Prolog, 69 bytes `f(X)` succeeds if it can find a value I where X = I\2^I+1. The range hint stops it running out of stack space, but it's enough for the range of Cullen numbers up to 10^9 in the question spec. ``` :-use_module(library(clpfd)). f(X):-I in 0..30,X#=I2^I+1,label([I]). ``` e.g. ``` f(838860801). true ``` [Answer] # [cQuents](https://github.com/stestoltz/cQuents), 9 bytes ``` $0?1+$2^$ ``` [Try it online!](https://tio.run/##Sy4sTc0rKf7/X8XA3lBbxShO5f9/I1MA "cQuents – Try It Online") ## Explanation ``` $0 n is 0-indexed ? Mode query. Given input n, output true/false for if n is in the sequence. 1+$2^$ Each item in the sequence equals `1+index2^index` ``` [Answer] # [Arturo](https://arturo-lang.io), 29 bytes ``` $=>[in?&map 0..25'n->1+n2^n] ``` [Try it](http://arturo-lang.io/playground?hBfxpN) [Answer] # [Raku](https://raku.org/), 30 bytes ``` {$_∈({1+$++2$++}...>$_)} ``` [Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WiX@UUeHRrWhtoq2tpaRlhaQqtXT09OyU4nXrP1fnFipoKQSr2Brp1CdpqASX6ukkJZfpGCop2dk@h8A "Perl 6 – Try It Online") The parenthesized expression is a list of generated Cullen numbers, taken up to the point where a number is greater than the input argument (`* > $_`). Then we just check that the input argument is a member of that list (`∈`). [Answer] # [Japt](https://github.com/ETHproductions/japt) [`-d`](https://codegolf.meta.stackexchange.com/a/14339/), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) ``` ÑpU ¶NÉ ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWQ&code=0XBVILZOyQ&input=MjU) ``` ÑpU ¶NÉ :Implicit map of each U in the range [0,input) Ñ :Multiply by 2 pU :Raised to the power of U ¶ :Is equal to N :Array of all inputs É :Minus 1 :Implicit output of whether or not any U returns true ``` [Answer] # [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes ``` ʀ:E›c ``` [Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwiyoA6RSrigLpjIiwiIiwiMVxuM1xuNVxuOVxuMTJcbjI1Il0=) ## Explained ``` ʀ:E›c ʀ: # push 2 copies of the range [0, input] E # 2 ** x for x in ^ * # vectorised multiply with the other copy › # + 1 c # contains the input? ``` [Answer] # [Thunno](https://github.com/Thunno/Thunno) `D`, \$ 11 \log\_{256}(96) \approx \$ 9.05 bytes ``` RD2@zs1-Aq ``` [Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_abSSi1LsgqWlJWm6FquDXIwcqrSKDXUdCyEiUIkFi4xMISwA) #### Explanation ``` RD2@zs1-Aq # Implicit input RD # Push range(input) and duplicate 2@ # Pop one copy and push 2 ** each z* # Multiply elementwise s1- # Push the input decremented Aq # Is this in the list? ``` [Answer] # [Pyt](https://github.com/mudkip201/pyt), 8 bytes ``` Đ0⇹ŘĐ«⁺∈ ``` [Try it online!](https://tio.run/##ARoA5f9weXT//8SQMOKHucWYxJDCq@KBuuKIiP//MQ "Pyt – Try It Online") ``` Đ implicit input; Đuplicate 0⇹Ř Řangify from 0 to n Đ Đuplicate « bitshift left ⁺ increment ∈ is input in list of Cullen numbers?; implicit print ``` ]
[Question] [ ### Background The Sidi polynomial of degree \$n\$ – or the \$(n + 1)\$th Sidi polynomial – is defined as follows. $$S\_n(x) = \sum^n\_{k=0}s\_{n;k}x^n \text{ where } s\_{n;k} = (-1)^k\binom n k (k+1)^n$$ The Sidi polynomials have several interesting properties, but so do their coefficients. The latter form OEIS sequence [A075513](https://oeis.org/A075513). ### Task Write a full program or a function that, given a non-negative integer \$n\$, prints or returns the absolute sum of the coefficients of the Sidi polynomial of degree \$n\$, that is $$\Sigma\_n = \sum^n\_{k=0}\|s\_{n;k}\|$$ These sums form OEIS sequence [A074932](https://oeis.org/A074932). If you prefer 1-based indexing, you can take a positive integer \$n\$ instead and compute the absolute sum of the coefficients of the \$n\$th Sidi polynomial. Because this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), you must make your code as short as possible. All standard rules apply. ### Test cases (0-based) ``` n Σ 0 1 1 3 2 18 3 170 4 2200 5 36232 6 725200 7 17095248 8 463936896 9 14246942336 ``` ### Test cases (1-based) ``` n Σ 1 1 2 3 3 18 4 170 5 2200 6 36232 7 725200 8 17095248 9 463936896 10 14246942336 ``` [Answer] # [Python 2](https://docs.python.org/2/), 43 bytes ``` f=lambda n,k=1:k/n or nf(n,k+1)+kf(n-1,k) ``` [Try it online!](https://tio.run/nexus/python2#FYvBCoAgEAXP9RXvIrVpxHYM@hjDjNjaQvp/09sww@S4Xv7egoc6WXmRSfEk6BD7IiyTlYojO6Eca8GpSF6PvWcHZlra5k2nfujMHGCYQweDcqN8RPkH "Python 2 – TIO Nexus") ### A different approach Ever since I posted this challenge, I tried to come up with a recursive solution to this problem. While I failed using nothing more than pen and paper, I managed to turn the formula to golf into a practical problem – at least for certain definitions of practical – which made it easier to analyze. Imagine a game show with \$k + m\$ candidates that works as follows. In round 1, all candidates have to accomplish a certain task as fast as they can. The \$k\$ candidates that accomplish the task the fastest win \$$1\$ each and advance to round 3. In round 2, the \$m\$ remaining candidates get a second chance to join the other \$k\$. Each candidate is asked a question. If they answer the question correctly, they win \$$1\$ and advance to round 3. However, if they fail to answer the question, they are eliminated from the game. This means round 3 will have between \$k\$ and \$k + m\$ candidates, depending on how many can answer their questions. Round 3 consists of \$m\$ more contests that are similar to round 1. In each contest, the participants have to accomplish a certain task. Unlike round 1, only one candidate receives a prize, but all candidates get to participate in the next contest. Each contests pay twice as much as the contest before it; the first one pays \$$2\$ and the last one \$$2^m\$. Note that since all prizes are powers of two, knowing how much prize money a candidate earned means we know if they advanced to round 3 and which of the contests of round 3 they won. Assume you're watching the game show and round 1 is already over, so you know which \$k\$ candidates have already reached round 3 and which \$m\$ candidates are still stuck in round 2. In how many ways can the remaining prize money be distributed? Once we know which of the second round's \$m\$ candidates have advanced to round 3, it's easy to calculate the possible outcomes for this specific scenario. If \$j\$ candidates advance, there are \$k + j\$ total candidates in round 3, and thus \$k + j\$ possible outcomes for each contest. With \$m\$ individual contests in round 3, this makes \$(k + j)^m\$ outcomes for all \$m\$ contests. Now, \$j\$ can take any value between \$0\$ and \$m\$, depending on which candidates answer correctly in round 2. For each fix value of \$j\$, there are \$\binom{m}{j}\$ different combinations of \$j\$ candidates that could have advanced to round 3. If we call the total number of possible outcomes for \$k\$ round 3 candidates and \$m\$ round 2 candidates \$g(m, k)\$, we get the following formula. $$g(m,k) = \sum\_{j=0}^m \binom mj (j+k)^m$$ If we fix \$k = 1\$, we get the following special case, which constitutes our new approach to solve the original problem. $$g(m,1) = \sum\_{j=0}^m \binom mj (j+1)^m = \sum\_{j=0}^m \|s\_{m;j}\| = \Sigma\_m $$ ### A recursive formula Now, assume that you fell asleep during the commercials after round 1, and woke up just in time to see who won the last contest of round 3 and thus the grand prize of \$2^m k$\$. You don't have any other information, not even how much prize money that candidate won in total. In how many ways can the remaining prize money be distributed? If the winner was one of the \$m\$ candidates of round 2, we already now that they must have advanced to round \$3\$. Thus, we effectively have \$k + 1\$ candidates in round 3, but only \$m - 1\$ candidates in round 2. Since we know the winner of the last contest, there are only \$m - 1\$ contests with uncertain outcomes, so there are \$g(m - 1, k + 1)\$ possible outcomes. If the winner is one of the \$k\$ candidates that skipped round 2, the calculation becomes slightly trickier. As before, there are only \$m - 1\$ rounds left, but now we still have \$k\$ candidates in round 3 and \$m\$ candidates in round 2. Since the number of round 2 candidates and the number of round 3 contests are different, the possible outcomes cannot be calculated with a simple invocation of \$g\$. However, after the first round 2 candidate has answered – rightly or wrongly – the number of round 2 candidates once again matches the \$m - 1\$ round 3 contests. If the candidate advances, there are \$k + 1\$ round 3 candidates and thus \$g(m - 1, k + 1)\$ possible outcomes; if the candidate is eliminated, the number of round 3 candidates remains at \$k\$ and there are \$g(m - 1, k)\$ possible outcomes. Since the candidate either advances or not, there are \$g(m - 1, k + 1) + g(m - 1, k)\$ possible outcomes combining these two cases. Now, if we add the potential outcomes for all \$k + m\$ candidates that could have won the grand prize, the result must match \$g(m, k)\$. There are \$m\$ round 2 contestants that lead to \$g(m - 1, k + 1)\$ potential outcomes each, and \$k\$ round 3 contestants that lead to \$g(m - 1, k + 1) + g(m - 1, k)\$ ones. Summing up, we get the following identity. \begin{align\} g(m,k) &= m \cdot g(m-1,k+1) + k \cdot (g(m-1,k+1)+g(m-1,k)) \\ &= (m+k) \cdot g(m-1,k+1) + k \cdot g(m-1,k) \end{align\} Together with the base case $$g(0,k)=1$$ these two formulae characterize the function \$g\$ completely. ### A golfy implementation While ``` g=lambda m,k=1:0*m or(m+k)g(m-1,k+1)+kg(m-1,k) ``` (49 bytes, `0m` yields 1* once m drops to 0) or even ``` g=lambda m,k=1:m<1 or(m+k)g(m-1,k+1)+kg(m-1,k) ``` (48 bytes, returns True instead of 1) would be valid solutions, there are still bytes to be saved. If we define a function f that takes the number n of round 1 candidates instead of the number m of round 2 candidates as first argument, i.e., $$f(n,k)=g(n-k,k)$$ we get the recursive formula \begin{align\} f(n,k) &= g(n-k,k)\\ &= ((n-k)+k) \cdot g((n-k)-1,k+1)+k\cdot g((n-k)-1,k) \\ &= n \cdot f((n-k-1)+(k+1),k+1)+k \cdot f((n-k-1)+k,k) \\ &= n \cdot f(n,k+1) + k \cdot f(n-1,k) \end{align\} with base case $$f(k,k)=g(k-k,k)=g(0,k)=1$$ Finally, we have $$f(n,1)=g(n-1,1)=\Sigma\_{n-1}$$ so the Python implementation ``` f=lambda n,k=1:k/n or nf(n,k+1)+kf(n-1,k) ``` (`k/n` yields 1 once \$n = k\$) solves the task at hand with 1-based indexing. [Answer] # Mathematica, ~~33~~ 32 bytes Saved one byte thanks to [JungHwan Min](https://codegolf.stackexchange.com/users/60043/junghwan-min). ``` Binomial[#,r=0~Range~#].(r+1)^#& ``` [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), 10 bytes ``` Ý©¹c®>¹mO ``` Uses the CP-1252* encoding. [Try it online!](https://tio.run/nexus/05ab1e#@3947qGVh3YmH1pnd2hnrpb///@WAA "05AB1E – TIO Nexus") [Answer] # Pyth - ~~13~~ 12 bytes Just implements the formula without the `(-1)^k` part. ``` sm.cQd^hdQh ``` [Test Suite](http://pyth.herokuapp.com/?code=sm%2a.cQd%5EhdQh&test_suite=1&test_suite_input=0%0A1%0A2%0A3%0A9&debug=0). [Answer] # [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~27~~ 16 bytes ``` 1+(⍳!⊢)+.×⊢⍨1+⍳ ``` [Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTflfbaitYfiobbLGo65Fio96VxjoPOrdrPmod6umtt7h6UBaCyhoqA0UBLJruao18CvUQVIKNFkDyFEEasBjIDZVIDvgykCitf@BymCqwOYgKfif9qhtwqPevkddzY961zzq3XJovfGjtomP@qYGBzkDyRAPz@D/aQqGXGkKRkBsDMQmQGwKAA "APL (Dyalog Extended) – Try It Online") Formula taken from caird coinheringaahing. -11 bytes from Bubbler (conversion to tacit form.) ## Explanation ``` 1+(⍳!⊢)+.×⊢⍨1+⍳ 1+⍳ 1 + range 1 - n ⊢⍨ to the power n (⍳!⊢) binomial coefficients of n +.× inner(dot) product of the two 1+ + 1 ``` [Answer] ## R, 36 bytes ``` sum(choose(n<-scan(),0:n)(0:n+1)^n) ``` R's vectorization comes in handy here when applying the formula. [Answer] # [MATL](https://github.com/lmendo/MATL), 12 bytes ``` t:XnG:QG^sQ ``` Input is 0-based. [Try it online!](https://tio.run/nexus/matl#@19iFZHnbhXoHqdVHPj/vyUA "MATL – TIO Nexus") ### Explanation Consider input `5` as an example. ``` t % Take n implicitly. Duplicate % STACK: 5, 5 : % Range [1 2 ...n] % STACK: 5, [1 2 3 4 5] Xn % N-choose-k, vectorized % STACK: [5 10 10 5 1] G:Q % Push [2 3 ... n+1] % STACK: [5 10 10 5 1], [2 3 4 5 6] G^ % Raise to n % STACK: [5 10 10 5 1], [32 243 1024 3125 7776] * % Multiply, element-wise % STACK: [160 2430 10240 15625 7776] s % Sum of array % STACK: 36231 Q % Add 1. Display implicitly % STACK: 36232 ``` [Answer] # [J](http://jsoftware.com/), 19 bytes ``` +/@((!{:)>:^{:)@i. ``` Uses one-based indexing. [Try it online!](https://tio.run/nexus/j#@5@mYGuloK3voKGhWG2lqWVnFQekHDL1uLhSkzPyFTR09NKUDDQV7KwUMvUUDA0q/v8HAA) ## Explanation ``` +/@((!{:)>:^{:)@i. Input: integer n i. Range [0, 1, ..., n-1] ( )@ Operate on that range {: Get the last value, n-1 >: Increment, range becomes [1, 2, ..., n] ^ Exponentiate. [1^(n-1), 2^(n-1), ..., n^(n-1)] ( {:) Get the last value, n-1 ! Binomial coefficient. [C(n-1, 0), C(n-1, 1), ..., C(n-1, n-1)] * Multiply +/@ Reduce by addition ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~8~~ 7 bytes ``` cŻḋŻ‘Ɗ ``` [Try it online!](https://tio.run/##y0rNyan8/z/56O6HO7qP7n7UMEPrWNf///9NAQ "Jelly – Try It Online") This is a trivial modification of [user80092's answer](https://codegolf.stackexchange.com/a/163186/66833), but given that the user has deleted their account, this seems like an acceptable solution ## How it works ``` cŻḋŻ‘Ɗ - Main link. Argument: n (integer) e.g. 5 Ż - Range from 0 to n [0, 1, 2, 3, 4, 5] c - Binomial coefficient [1, 5, 10, 10, 5, 1] Ɗ - Last three links as a monad: Ż - Generate the range from 0 to n... [0, 1, 2, 3, 4, 5] ‘ - Increment each [1, 2, 3, 4, 5, 6] * - Raise to the power of n [1, 32, 243, 1024, 3125, 7776] ḋ - Dot-product 36232 ``` [Answer] # Maxima, 39 bytes ``` f(n):=sum(binomial(n,k)(k+1)^n,k,0,n); ``` [Answer] # PARI/GP, 35 bytes ``` n->sum(k=0,n,binomial(n,k)(k+1)^n) ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes ``` cR×R‘ƊS‘ ``` [Try it online!](https://tio.run/##y0rNyan8/z856PD0oEcNM7SOdQUDqf///5sCAA "Jelly – Try It Online") ## How it works ``` cR×R‘ƊS‘ - Main link. Argument: n (integer) e.g. 5 R - Range from 1 to n [1, 2, 3, 4, 5] c - Binomial coefficient [5, 10, 10, 5, 1] Ɗ - Last three links as a monad: R - Link 1: Range from 1 to n [1, 2, 3, 4, 5] ‘ - Link 2: Increment [2, 3, 4, 5, 6] * - Link 3: To the power of n [32, 243, 1024, 3125, 7776] × - Multiply, pairwise [160, 2430, 10240, 15625, 7776] S - Sum 36231 ‘ - Increment 36232 ``` [Answer] # Axiom, 39 bytes ``` f(n)==sum(binomial(n,i)*(i+1)^n,i=0..n) ``` test code and results ``` (35) -> [[i,f(i)] for i in 0..9] (35) [[0,1], [1,3], [2,18], [3,170], [4,2200], [5,36232], [6,725200], [7,17095248], [8,463936896], [9,14246942336]] ``` ]
[Question] [ Your challenge is to write N snippets of code such that, when you concatenate the first K ≥ 1 together, they produce the number K. The higher N, the better. Here's the catch: you may not use any character more than once across your snippets. ## Rules * You may use the same character multiple times in one (and only one) snippet. * These snippets must be concatenated in the order they are presented, without skipping any. * You must write at least two snippets. * All snippets must be in the same language. * Remember: snippets do not have to be full programs or functions, nor do they have to function on their own. `-1` is a valid snippet in Java, e.g. * All resulting concatenations must output the respective K value. * The winner is the person with the highest N value. Tie-breaker is shortest overall program length in bytes. ## Example Suppose your snippets were `AD`, `xc`, `123`, and `;l`. Then: * `AD` should produce `1` * `ADxc` should produce `2` * `ADxc123` should produce `3` * and `ADxc123;l` should produce `4`. This program would have a score of 4. [Answer] # Perl 5, ~~50,091~~ 151 snippets First snippet: ``` use utf8; print length A ``` ~~2nd through 26th snippets: `B` through `Z`~~ 27th through 46nd snippets: `a` through `z`, excluding the characters in "length" 47th through 56th snippets: `0` through `9` 57th snippet: `_` ~~The remaining snippets are the 50,105 individual Unicode characters which Perl regards as "word" characters, excluding the 14 distinct word characters in the initial snippet, in any order.~~ Well, it was a nice thought, but it turns out that after a certain length Perl gives you an "identifier too long" error. This is the longest combined program I was able to get Perl to digest: ``` use utf8; print length A012345679BCDEFGHIJKLMNOPQRSTUVWXYZ_abcdjkmoqsvwxyzĀāĂăĄąĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪīĬĭĮįİıĲĳĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇňŉŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞşŠšŢţ ``` The perldiag manual page says "Future versions of Perl are likely to eliminate these arbitrary limitations" but my Perl 5.18 has not done so. Explanation: In non-strict mode, Perl 5 interprets unquoted strings of word characters as "barewords," essentially quoting them for you automatically. They're usually best avoided, but they sure help here! [Answer] # [Python 3](https://docs.python.org/3/), 1 112 056 snippets, 4 383 854 bytes This is very similar to [@WheatWizard's Python 2 answer](https://codegolf.stackexchange.com/a/146842/12012). I started working on this shortly before it was posted, but sorting out Python's quirks regarding non-ASCII characters and long lines took some time. I discovered that Python reads lines 8191 bytes at a time, and when those 8191 bytes contain only a part of a multi-byte character, Python throws a SyntaxError. The first snippet uses an encoding from [Fewest (distinct) characters for Turing Completeness](https://codegolf.stackexchange.com/a/110677/12012). ``` exec('%c'%(111+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(111+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(111)+'%c'%(111+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1)+'%c'%(11+11+11+11+1+1+1+1+1)+'%c'%(11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11)+'%c'%(11+11+11+11+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1++++++++++1)) ``` This monstrosity simply build the following string and executes it. ``` print(len(open(__file__).read())-1260) ``` The following snippets are all exactly one character long. The next three characters are `\n`, `\r`, and `#`. All remaining Unicode characters (except surrogates) follow in a specific order, so they align with the 8191-byte boundary. The following script generates the appropriate programs for input k between 1 and 1112056. ``` j = 4 s = "exec('%c'%(111+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(111+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(111)+'%c'%(111+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1)+'%c'%(11+11+11+11+1+1+1+1+1)+'%c'%(11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11)+'%c'%(11+11+11+11+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1++++++++++1))" l = 1 c = \ [ None, [n for n in range(0x80) if chr(n) not in "\n\r#%'()+1cex"], [range(0x80, 0x800)], [range(0x800, 0xd800), range(0xe000, 0x10000)], [range(0x10000, 0x110000)] ] k = int(input()) assert k in range(1, 1112057) s += '\n\r#'[:k - 1] k -= 4 while j: while k > 0 and c[j] and l + j < 8191: s += chr(c[j].pop()) l += j k -= 1 if k < 1: print(end = s) break elif c[j] == []: j -= 1 else: s += chr(c[8191 - l].pop()) print(end = s) k -= 1 s = '' l = 0 ``` [Answer] # [Python 2](https://docs.python.org/2/), score 32 ``` for r in range(32):locals()[''.join(map(chr,range(65,66+r)[:26]+range(117,92+r)))]=r+1 print A ``` With subsequent snippets `B`, `C`, `D`, … `Y`, `Z`, `u`, `v`, `w`, `x`, `y`, `z`. In a twist of dramatic irony, Python 3 supports Unicode identifiers, which would let us get very silly with this trick — but it can’t `print` without parentheses. I could cram digits into the identifier, too, but I don’t think this approach is very fun to squeeze more out of. [Try it online!](https://tio.run/##K6gsycjPM/r/Py2/SKFIITNPoSgxLz1Vw9hI0yonPzkxp1hDM1pdXS8rPzNPIzexQCM5o0gHosTMVMfMTLtIM9rKyCxWGyJmaGiuY2kEFNTUjLUt0jbkKijKzCtRcHRydnF1c/fw9PL28fXzDwgMCg4JDQuPiIwqLSuvqKz6/x8A "Python 2 – Try It Online") # [Python 2](https://docs.python.org/2/), score 18, less cheat-y ``` print 0x10-1&0x1 print 0x10-1&0x12 print 0x10-1&0x123 print 0x10-1&0x1234 print 0x10-1&0x12345 print 0x10-1&0x123456 print 0x10-1&0x1234567 print 0x10-1&0x12345678 print 0x10-1&0x123456789 print 0x10-1&0x123456789A print 0x10-1&0x123456789Ab print 0x10-1&0x123456789Abc print 0x10-1&0x123456789Abcd print 0x10-1&0x123456789AbcdE print 0x10-1&0x123456789AbcdEf print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())) print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))\|[[[]]>[]][[]>[]] print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))\|[[[]]>[]][[]>[]]<<False*False ``` [Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EwaDC0EDXUA1IcaELGGGKGGMRMsEmZopV0Ay7qDkOYQtc4pY4JRxxyyThkUrGJ5eCV9IVv2waAek4DQ0NTVtbDU1N7VEGEkNzNNzIC7ea6Ojo2Fg7IAbSIGo0IKkUkDY2bok5xalaWmDq/38A "Python 2 – Try It Online") [Answer] # JavaScript (ES6, V8 6.x), ~~52~~ ~~50298~~ ~~119526~~ ~~119638~~ ~~119683~~ 128781 snippets, ~~88~~ ~~149147~~ ~~575179~~ ~~575631~~ ~~576121~~ 612789 bytes Farther below is a Stack Snippet that generates the full program, evaluates it, and creates a download link for the file. That snippet will continue to generate better answers as later versions of Unicode are supported by newer versions of JavaScript, which add new valid identifiers to the language. ### Using ASCII only ``` console.log(new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn$$00112233445566778899AABBCCDDEEFFGGHHIIJJKKLLMMNNOOQQRRSSTTUUVVWWXXYYZZ__aabbccddffiijjkkmmppqqssuuvvzz) ``` ## Explanation This uses the metaprogramming technique of [`Proxy`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) to enable a [get handler trap](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get) on the object and access the property name as a string, returning the identifier's `length / 2` as its value. With the first snippet starting as `new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn`, each additional snippet added increments the string `length` of the identifier by `2` by making sure to `.repeat()` the respective code point twice for 2 byte utf-16 characters, and once for 4 byte utf-16 characters. ## Identifiers in JavaScript In the [ECMAScript Specification](https://tc39.github.io/ecma262/#prod-IdentifierName), an `IdentifierName` is defined with the following grammar: > > > ``` > IdentifierName:: > IdentifierStart > IdentifierName IdentifierPart > > IdentifierStart:: > UnicodeIDStart > $ > _ > \UnicodeEscapeSequence > > IdentifierPart:: > UnicodeIDContinue > $ > _ > \UnicodeEscapeSequence > <ZWNJ> > <ZWJ> > > UnicodeIDStart:: > any Unicode code point with the Unicode property “ID_Start” > > UnicodeIDContinue:: > any Unicode code point with the Unicode property “ID_Continue” > > ``` > > ## Generating the answer Initially using the "ID\_Continue" Unicode property, I wrote a Node.js script that generates the full answer. Now it's just a client-side script that uses a naive `eval()` to test for valid characters, iterating through all the unicode code points instead: ``` // first snippet let answer = 'new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn' const used = Array.from( answer, c => c.codePointAt(0) ).sort( (a, b) => a - b ) // create a O(1) lookup table for used characters in first snippet const usedSet = Array.from( { length: Math.max(...used) + 1 } ) for (const codePoint of used) { usedSet[codePoint] = true } // equal to 1 for first snippet let snippets = eval(answer) let identifier = '' for (let codePoint = 0, length = 0x110000; codePoint < length; codePoint++) { const character = String.fromCodePoint(codePoint) // if unused if (usedSet[codePoint] === undefined) { // if valid `IdentifierPart` try { eval(`{let _${character}$}`) } catch (error) { // console.log(character) continue } // repeat so that `snippet.length === 2` identifier += character.repeat(2 / character.length) snippets++ } } // number of snippets generated console.log(`snippets: ${snippets}`) const program = `console.log(${answer + identifier})` // output of program to validate with eval(program) // download link to check number of bytes used dl.href = URL.createObjectURL(new Blob([program], { type: 'text/javascript' })) ``` ``` <a id=dl download=answer.js>Click to Download</a> ``` Running `stat -f%z answer.js` yields a byte count of 612802, but we subtract 13 bytes for the `console.log(` and `)` wrapping the actual submission. ## Encoding The source is stored as utf-8, which is reflected in the enormous byte count of the answer. This is done because Node.js can only run source files encoded in utf-8. JavaScript internally stores strings with utf-16 encoding, so the string "character length" returned in JavaScript is actually just half the number of bytes of the string encoded in utf-16. [Answer] # [Python 2](https://docs.python.org/2/), score ~~6~~ 10 +3 thanks to pizzapants184 +1 thanks to WheatWizard ``` 4/4 2 -~0 +1 \|5 ^3 &776%6 and 8 if[]else[9][9>9] .__xor__((""=="").__xor__((""=="")<<(""==""))) ``` [Try it online!](https://tio.run/##ZY7RCoIwGIWv3VOMQW3LsjTTFO1FxhpisxayyZQoiF7d3IV00c33f5zDD6d7DTejo3Hsteo6OfSwhAzgeBvjNcCryHHz2bnjh47vg@N577hM02SROKv0BR6dqIZx2faSZZxlp4y7LBDiaawQhCBUlgjRv6AoZqN0@uCgMRYqqDS0lb5K0kpN5oGU5sCrp5kYB3ejfgXLlR9yCrzOKj3Aehb5qFpSUzCOXw "Python 2 – Try It Online") [Answer] # TI-Basic (83 series, OS version 1.15 or higher), score: ~~17~~ ~~18~~ ~~19~~ 24 (Tiebreaker: 53 bytes.) You can get a very large score by abusing string length as usual: begin with ~~`length("A`~~ `length("length(` (as @Scrooble points out) and keep adding single-token snippets to the end. TI-Basic has over 700 of those, so that actually works pretty well. But here's another approach: ``` int(log(11 2 3 4 5 6 7 8 9 0 Xmax Ymax nMax abs(Xmin Ymin ππ eee ³ ² ₁₀^(₁₀^(X +e^(⁻e^(Y)))) /√(sub(Z! ° randrandrand ``` Note that TI-Basic is tokenized, so (for example) the `e^(` command does not use any of the characters `e`, `^`, `(`. Relies on an undocumented feature of the `sub(` command: in addition to finding substrings, it can also be used to divide a number by 100. This works if it's running on a fresh calculator, which lets us assume that `X`, `Y`, `Z` are all zero, that the window variables are set to their standard values, that the calculator is in radian mode, and that `rand`'s first three outputs will be about `0.943`, `0.908`, `0.146`. [Answer] # [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 25 bytes, Score 5 ``` ' '.count2+!""-(-1)\|%{5} ``` Snippet 1: `' '.count` outputs `1`. It does this by taking the `.count` of an string, which is one because there is only one string. [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X11BXS85vzSv5P9/AA "PowerShell – Try It Online") Snippet 2: `2` outputs `2` because we take the `1` from the previous snippet and multiply it by two [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X11BXS85vzSvRMvo/38A "PowerShell – Try It Online") Snippet 3: `+!""` outputs `3` by adding the Boolean-not of an empty string. This implicitly casts the empty string to `$true`, which is again implicitly cast to `1`, so we're adding one [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X11BXS85vzSvRMtIW1FJ6f9/AA "PowerShell – Try It Online") Snippet 4: `-(-1)` outputs `4` by simply subtracting negative one [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X11BXS85vzSvRMtIW1FJSVdD11Dz/38A "PowerShell – Try It Online") Snippet 5: `\|%{5}` outputs `5` by taking the previous number into a loop and each iteration of that loop (only one, because there's only one input number) outputs `5` [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X11BXS85vzSvRMtIW1FJSVdD11CzRrXatPb/fwA "PowerShell – Try It Online") Thanks to Jan for an alternate means of coming up with `4` and a crafty way of coming up with `5`. [Answer] # C, 10 snippets, 45 bytes ``` sizeof(char) // sizeof(char) = 1 <<9/9 // Multiply by two. \|1 // 2 or 1 = 3 ,4 // Discard previous expression, return 4. +!!8 // Add one. ^3 // 5 xor 3 = 6 &66 // 3 and 66 = 2, 5 xor 2 = 7 (& has higher precedence) ??'0xF // Trigraph for '^'. 7 xor 15 = 8 -~-2 // ~-2 = 1, 7 xor 14 = 9 57%5 // 157%5 = 2, 7 xor 13 = 10 ``` [Try it online!](https://tio.run/##S9ZNT07@n5lXopCbmJmnoclVzaUABCCBTAVbBY2Y/8WZVan5aRrJGYlFmlw2Npb6llw1hlw6JlzaiooWXHHGXGpmZlz29uoGFW5cunW6Rlxapuaqpv9BpmhaFxQBTUrTUFJNUdJRyNS05qr9/y85LScxvfi/bklRZnpRYkFGMQA) [Answer] # [MATL](https://github.com/lmendo/MATL), Score ~~8~~ 15, ~~64~~ 123 bytes ``` rg % 1 Random number, make boolean (1) Q % 2 Increment Yq % 3 Nth prime a,E] % 4 any (convert to boolean 1. Do twice: Multiply by 2 T+ % 5 Add True F~_- % 6 Subtract negative (not(false)) = 6-(-1) :sI/ % 7 Range 1:6, sum (21), divide by 3 A8* % 8 All elements (True). Multiply by 8 d9 % 9 Clear stack, push 9 x10 % 10 Clear stack, push 10 WBPf % 11 Raise 2^10. Convert to binary [1 0 ... 0], flip [0 0 ... 1]. Find 23ZP % 12 Push 23, and calculate the distance between 11 and 23 yyyyyyyyyyyyyyyyyyyyyyyyhhhhhhhhhhhhhhhhhhhhhhhhz % 13. Duplicate and count elements tttttttttttttvvvvvvvvvvvn % 14 Duplicate and count elements OOOOOOOOOOOOOON& % 15 Add bunch of zeros, output size of stack ``` * Got to 12 with help from Luis Mendo! Using `11,23ZP` was his idea, along with changing `3` with `I` for snippet 7. * Got to 15 with more help from Luis. `OO...N&` was his idea. ~~More to come.~~ I don't know the MATL functions by heart, so I had to go back and forth and back and forth in the documentation... :) [Try it online!](https://tio.run/##y00syfn/vyg9MLIwUcc1NkTbrS5e16rYWN/RQivFssLQINwpIM3IOCqgEgfIwAGqSpBBGQLk@aMAP7X//wE "MATL – Try It Online") [Answer] # [V](https://github.com/DJMcMayhem/V), score 10 ``` é1 <C-a> r3 DÉ4 ñóä/5ñ ddá6 xÁ7 C8<esc> R9<C-c> ø.<cr>ÎA0 ``` [Try it online!](https://tio.run/##K/v///BKQxtn3US7ImOXw50mhzce3nx4ib7p4Y0pKYcXmlUcbjR3trBJLU62C7IEKku2O7xDj@twn6PB////dcsA "V – Try It Online") [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 253 bytes, score 250 ``` L}“L ``` Subsequent 1-char snippets: ``` ¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()+,-./0123456789:;<=>?@ABCDEFGHIJKMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{\|~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż ``` Note: `¶` may also be replaced by `\n`, they're the same byte in Jelly's codepage. After you append all those snippets, you can then append the 2-char snippet `”‘`. +1 thanks to [Dennis](https://codegolf.stackexchange.com/users/12012/dennis). [Try it online!](https://tio.run/##Dc3nUlpBHIfhW0nvvffeY3rv1RRDejVtWFQwoEmEGcEkKiDgJEECKLD/PQgzu4edc7yL394I4fs7z9vR7vF0Npttn4z3V5tMyKQckymZlhn5W2ZlTpbktKwbX1b5VUB9VwMqqmKNsBpRoyqjxlXeLjgVVVAVxRsRVZs1e87cefMXLFy0eMnSZctXrFy1es3ades3bNy0ecvWbdt37Ny1e8/effsPHDx0@MjRY8dPnDx1@szZc@cvXLx0@crVa9dv3Lx1@87d9nv3HzzseOR5/OTps@cvXr56/ebtu873Hz5@lmWZlySLctKwKcNKhpUNqxjGDSPDhGGWYVXDpg2raaYDOqgHdETHTCGnh3VKZ3XRSbkR3etGddiNuxk95Bbcok7PxN3qjE9PzIScNEQcvBu8D4KDp2AFwYvgZZAP5IfVB/oBSoKysFKgGkQvrCmIsJMB99mtOmgPgo/YLSZp5@06yAvqdnKgQVAMFAf9gfBDBCG@NiyIBHgPeD8EgadhhcAnwSugLlAAVj/oJ2gMNAErDapDfIFVgog44@BddqsO2VHwUbvFjDVaKwbqcf6BoqAhUAL0FyIAEYL41qga77DxxprN/w "Jelly – Try It Online") [Answer] # [Lenguage](https://esolangs.org/wiki/Lenguage), 1 112 064 snippets The nth snippet consists of 23n-1* repetitions of the nth non-surrogate Unicode character, up to and including the 1 112 064th and last non-surrogate character of the current Unicode standard. Output is in unary (using the null byte as digit) for simplicity. Decimal is possible, but it will make the programs even longer. With unary, we can test the first programs. For n = 1, we get 4 repetitions of U+0000. This is equivalent to the brainfuck program `.`, which prints one null byte. For n = 2, we get 32 repetitions of U+0001, for a total of 36 characters. This is equivalent to the brainfuck program `..`, which prints two null bytes. For n = 3, we get 256 repetitions of U+0002, for a total of 292 characters. This is equivalent to the brainfuck program `...`, which prints three null bytes. And so forth, up to n = 1 112 064. [Answer] # [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), score 13, 58 bytes ``` I3% #I is the default input radix, 10, mod 3 yields 1 1+ #Add one 2^2^2^Z #2^8=256, Z pushes the number of digits to the stack 6v #Square root of 18 = ~4.24, at precision 0 we get 4 c5 #Start getting lazy, clear the stack and push 5 _F-E- #Subtract negative 15, then subtract 14 ss7 #Lazy, 'drop' the value by storing it, push 7 SS8 #Lazy, 'drop' the value by storing it, push 8 d::9 #Lazy, 'drop' the value by storing it, push 9 ;;kA #Recall element 9 from nonexistant array ; which is zero, set precision, push A (10) iB #Set input radix to 10, push B (11) oD #Set output radix to 11, push D (13, or 12 in base 11) 4CCCCCCr/4C/CC/4/ #We have division and the digits 4 and C left, this might not be the optimal way to get us to 13 but it does the job ``` [Try it online!](https://tio.run/##HcG7DkAwAAXQ/f6HhUg96tmJIjF3MzBUbiIGiSZ@v8I5u/V@zgMijYhs/S5EGT6ELYhtiseYcK4ijKmJpG0bQqmzI46euAZC6t8tpBZaCyno/Qs "dc – Try It Online") (Note, the TIO version adds an `f` after each snippet to print the entire stack, showing that each snippet only leaves a single value on the stack; also I forgot the leading space on the last snippet which doesn't matter functionally when they're broken apart by line breaks but does count to my character usage) Each additional snippet concatenation leaves the desired value and only the desired value on the stack. After hitting 12, I had kind of run out of ways to eat the stack. I tried to use math operations early on since they gobble up the stack and as we get into larger numbers it gets trickier to manage that way. When all is said and done, I have only the digit 0 left to play with and very little in the way of stack-popping, so I think 13 is pretty close to maxed out. I'm sure there are many similar (and likely shorter) ways of accomplishing this in dc, this just kind of fell into place. Note that cygwin handles A-F mixed in with 0-9 differently from most versions of dc, `44C4r/CC 4//` works for the final snippet in cygwin. [Answer] # BASIC (ZX Spectrum), score 244 (new score 247) [is this cheating?] Snippet 1: ``` 2356 PRINT PEEK (PEEK 23635+256PEEK 23636+2)+256PEEK (PEEK 23635+256PEEK 23636+3)-56-66 ``` Snippet 2: `:` Snippet 3: `REM` Snippets 4-244: Single-character snippets, using all characters not in snippets 1, 2 and 3. Explanation Characters On Spectrum, `PRINT` is a single character (code 245). The snippet 1 uses 11 different characters: `2`, `3`, `5`, `6`, `+`, `-`, ``, `(`, `)`, `PRINT` and `PEEK` What you see as spaces are a part of characters `PRINT` and `PEEK`, so the space itself hasn't been used. I decided to give the line number 2356 because these are the only digits present in the code. Characters 13 and 14 are not allowed. That means there are 243 characters left for snippets 2-244, starting with `:` and `REM` to avoid the code that would produce error or do anything else. How it works* This is why I'm not sure whether this answer is by the book. 23635 is the memory location for 16-bit system variable PROG, stored as LH. (The value is usually 23755. But apart from wrong result if it happens not to be the case, using this number directly, even though it would shorten the code, would cost me extra digit characters.) The value of PROG is the memory location where the program itself is stored. The first two bytes are the line number stored as HL, the following two bytes are the length of the line stored as LH. That's how the program looks up its own line's length, so something appropriate needs to be subtracted Saving characters Considering how numbers are stored, the line could have ended with -114 so that snippet 1 would produce 1. But I didn't want to use extra digits, so I instead took away two 2-digit numbers, which then had to add up to 122; 56 and 66 did nicely. The code is a bit ugly with all nesting and calculating value of PROG (`PEEK 23635+256PEEK 23636`) twice. But if I stored it and then used the stored value, it would cost extra characters / snippets - the line could start like ``` 2356 LET p=PEEK 23635+256PEEK 23636: PRINT PEEK (s+2)... ``` which would use 4 additional characters: `LET`, `p`, `=` and `:`. Maybe I'll engineer this so that all numbers are calculated from numbers that use only 1 digit and gain 3 snippets. EDIT: Here is the new snippet 1 (that's how a long single line gets wrap-displayed on the Spectrum, so if you want to test the code , that will help you see that you typed it correctly): ``` 1111 PRINT +PEEK (PEEK (11111+11 111+1111+(1+1+1)(111-11)+1+1)+( 111+111+11+11+11+1)PEEK (11111+ 11111+1111+(1+1+1)(111+1-11))+1 +1)+(111+111+11+11+11+1)PEEK (P EEK (11111+11111+1111+(1+1+1)(1 11-11)+1+1)+(111+111+11+11+11+1) PEEK (11111+11111+1111+(1+1+1)* (111+1-11))+1+1+1)-111-111-111-1 11-111-111 ``` I could gain another snippet by avoiding the `+` and just make do with `-`. I'm not going to try it, this was enough of an ordeal. [Answer] # [Klein 011](https://github.com/Wheatwizard/Klein), 9 snippets Snippet 1 ``` !@1!aaaaaaaaaaaaaaaaaaaaa/a ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQT/z//7@BoSEA "Klein – Try It Online") Snippet 2 ``` 2((2\|bbb0b2bbbb4bbbbbbbb ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQTzTS0DCqSUpKMkgyApJJJklQ8P//fwNDQwA "Klein – Try It Online") Snippet 3 ``` c\3ccccccccccccccccccccc\ccccccccc3c6cccc9 c\ ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQTzTS0DCqSUpKMkgyApJJJklQwJUco2WcjA3EwFnGyWYgyhKo9v///waGhgA "Klein – Try It Online") Snippet 4* ``` ddddddddddddddddddddddd>$d:d:++-$:+:+++$:?:-$-+++ ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQTzTS0DCqSUpKMkgyApJJJklQwJUco2WcjA3EwFnGyWYgyhKoNgU7sFNJsUqx0tbWVbHSBlLaKlb2VroqukDW////DQwNAQ "Klein – Try It Online") Snippet 5 ``` ee ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQTzTS0DCqSUpKMkgyApJJJklQwJUco2WcjA3EwFnGyWYgyhKoNgU7sFNJsUqx0tbWVbHSBlLaKlb2VroqukBWaur///8NDA0B "Klein – Try It Online") Snippet 6 ``` fff ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQTzTS0DCqSUpKMkgyApJJJklQwJUco2WcjA3EwFnGyWYgyhKoNgU7sFNJsUqx0tbWVbHSBlLaKlb2VroqukBWampaWtr///8NDA0B "Klein – Try It Online") Snippet 7 ``` ggggg ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQTzTS0DCqSUpKMkgyApJJJklQwJUco2WcjA3EwFnGyWYgyhKoNgU7sFNJsUqx0tbWVbHSBlLaKlb2VroqukBWampaWlo6CPz//9/A0BAA "Klein – Try It Online") Snippet 8 ``` hh ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQTzTS0DCqSUpKMkgyApJJJklQwJUco2WcjA3EwFnGyWYgyhKoNgU7sFNJsUqx0tbWVbHSBlLaKlb2VroqukBWampaWlo6CGRk/P//38DQEAA "Klein – Try It Online") Snippet 9 ``` iiiii ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVAxERvQTzTS0DCqSUpKMkgyApJJJklQwJUco2WcjA3EwFnGyWYgyhKoNgU7sFNJsUqx0tbWVbHSBlLaKlb2VroqukBWampaWlo6CGRkZILA////DQwNAQ "Klein – Try It Online") ## Explanation This was a really fun challenge for Klein. Klein's unique topology allows for a lot of interesting stuff to be done. As you might notice answers 5-9 are just adding filler (letters do nothing in Klein so I used them as filler) to the code to stretch out the bounding box. This causes the ip to take a different path through earlier parts of the code because of Klein's unique topology. I'm going to make a full explanation later, but for now here is a easier to understand version of the program with all of the letters replaced with `.`s. ``` !@1!...................../.2((2\|...0.2....4........ .\3.....................\.........3.6....9 .\.......................>$.:.:++-$:+:+++$:?:-$-+++................. ``` [Try it online!](https://tio.run/##y85Jzcz7/1/RwVBRDxvQ1zPS0DCqAbIM9IxAAiYwGS69GC1jrHpi4CxjPTMQZcmFJIYK7FT0rPSstLV1Vay0gZS2ipW9la6KLpCFofT///8GhoYA "Klein – Try It Online") [Answer] # [><>](https://esolangs.org/wiki/Fish), Score: ~~Infinity~~ 1,112,064-6 = 1,112,058 ### Snippet 1 (6 bytes) ``` "l4-n; ``` This snippet outputs the amount of characters after the ; plus one. This can be extended to ~~infinite~~ very large amount of snippets of one character each. A quick google tells me there are 1,112,064 possible Unicode characters, minus the 6 I’ve already used. [Try](https://tio.run/##S8sszvj/XynHRDfP@v9/UwA) [It](https://tio.run/##S8sszvj/XynHRDfPOvH/f1MA) [Online](https://tio.run/##S8sszvj/XynHRDfPOjHp/39TAA) [Answer] # [R](https://www.r-project.org/), score: 79 Credit to [Sean's Perl answer](https://codegolf.stackexchange.com/a/146759/67312) for the inspiration; this abuses some quirks of the R interpreter. First snippet: ``` nchar(scan(,"")) a ``` subsequent snippets are the characters in: ``` bdefgijklmopqtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@$%^&_+\|\[]{}:?><; ``` [Try it online!](https://tio.run/##K/r/Py85I7FIozg5MU9DR0lJU5MrMSklNS09Mys7Jze/oLCktKy8orLK0cnZxdXN3cPTy9vH188/IDAoOCQ0LDwiMsrA0MjYxNTM3MIyoU7RQUU1Tk0rXrsmJjq2utbK3s7G@v9/AA "R – Try It Online") The [`scan`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/scan.html) function reads data from the file `""` which defaults to `stdin()`. The docs for [`stdin()`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/showConnections.html) indicate that: > > When R is reading a script from a file, the file is the ‘console’: this is traditional usage to allow in-line data (see ‘An Introduction to R’ for an example). > > > Hence, the subsequent data become the file. This can be trivially expanded, and can work with multiple different encodings. [Answer] # [Pyke](https://github.com/muddyfish/PYKE), 256 bytes, score 254 Please note that these are hex codes of the actual bytes, separated by spaces, since there the null byte (`\x00`) is included. Starting snippet: ``` 6C 22 00 ``` Subsequent 1-char snippets: ``` 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A 6B 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF ``` [Try it here!](https://pyke.catbus.co.uk/?code=6C+22+00+01+02+03+04+05+06+07+08+09+0A+0B+0C+0D+0E+0F+10+11+12+13+14+15+16+17+18+19+1A+1B+1C+1D+1E+1F+20+21+23+24+25+26+27+28+29+2A+2B+2C+2D+2E+2F+30+31+32+33+34+35+36+37+38+39+3A+3B+3C+3D+3E+3F+40+41+42+43+44+45+46+47+48+49+4A+4B+4C+4D+4E+4F+50+51+52+53+54+55+56+57+58+59+5A+5B+5C+5D+5E+5F+60+61+62+63+64+65+66+67+68+69+6A+6B+6D+6E+6F+70+71+72+73+74+75+76+77+78+79+7A+7B+7C+7D+7E+7F+80+81+82+83+84+85+86+87+88+89+8A+8B+8C+8D+8E+8F+90+91+92+93+94+95+96+97+98+99+9A+9B+9C+9D+9E+9F+A0+A1+A2+A3+A4+A5+A6+A7+A8+A9+AA+AB+AC+AD+AE+AF+B0+B1+B2+B3+B4+B5+B6+B7+B8+B9+BA+BB+BC+BD+BE+BF+C0+C1+C2+C3+C4+C5+C6+C7+C8+C9+CA+CB+CC+CD+CE+CF+D0+D1+D2+D3+D4+D5+D6+D7+D8+D9+DA+DB+DC+DD+DE+DF+E0+E1+E2+E3+E4+E5+E6+E7+E8+E9+EA+EB+EC+ED+EE+EF+F0+F1+F2+F3+F4+F5+F6+F7+F8+F9+FA+FB+FC+FD+FE+FF&input=&warnings=1&hex=1) [Answer] # Java 8, 7 snippets (19 bytes) ``` 1 2 -~0 >4?4:4 \|5 ^3 7%7 ``` Just a start, will continue working on it. [Try it here.](https://tio.run/##y0osS9TNL0jNy0rJ/v8/OSexuFjBNzEzr5pLQaGgNCknM1mhuCSxBEiV5WemKOQCpTSCS4oy89KjYxUSi9KLNUEqFRSCK4tLUnP18ktL9AqAsiU5eRqGmtY4pbSM8Erq1hkQkrczsTexMiFOVY0pserijIlXaa5qDlZcy1X7/z8A) Explanation:* Execution precedence is perhaps made clearer when I add parenthesis: ``` ((12)-~0)>4?4:4\|(5^(37%7)) ``` `ab`: Multiply `a` with `b` `~a`: `-a-1` * `a>b?x:y`: `if(a>b){ x }else{ y }` * `a\|b`: Bitwise-OR `a` with `b` * `a^b`: Bitwise-XOR `a` with `b` * `a%b`: `a` modulo-`b` [Answer] # [Python 2](https://docs.python.org/2/), 110 snippets Here is the complete snippet: ``` print((((len(open(__file__).read())-44.)))) # !"$%&'+,/012356789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`bcghjkmqsuvwxyz{\|}~ ``` [Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EAwhyUvM08guARHx8WmZOany8pl5RamKKhqamromJniYQcHEpMzAyMbOwsrFzcHLz8PELCAoJi4iKiUtISknLyMrJKygqqaiqqWtp6@gbGBoZm5qZW1haWdvY2tk7ODo5u7i6uXt4enn7@Pr5BwQGBYeEhoVHREZFx8TGJSQlp2dkZecWFpeWlVdUVlXX1NbV//8PAA "Python 2 – Try It Online") The first snippet is ``` print((((len(open(__file__).read())-44.)))) ``` And then the next 109 snippets are the next 109 bytes. This is pretty "cheaty" as Lynn puts it. The first snippet opens the file and subtracts 44 from its length, then each other snippet adds 1 to the length of the file without changing the logic of the program as a whole. thus increasing the result of the output by 1. [Answer] # TeX, score 61 (possibly 190) First snippet: ``` \def\len#1{\expandafter\glen\string#1=} \def\glen#1{\tlen} \def\tlen#1{\if#1=\let\tlen\end\number\count1\else\advance\count1by1\fi\tlen} \count1=-1 \catcode33=11 \catcode34=11 \catcode36=11 \catcode37=11 \catcode'46=11 \catcode40=11 \catcode41=11 \catcode42=11 \catcode43=11 \catcode44=11 \catcode45=11 \catcode46=11 \catcode47=11 \catcode56=11 \catcode57=11 \catcode'72=11 \catcode'73=11 \catcode60=11 \catcode62=11 \catcode63=11 \catcode64=11 \catcode'133=11 \catcode'135=11 \catcode'136=11 \catcode'137=11 \catcode'140=11 \catcode124=11 \catcode126=11 \len\t ``` Other 60 snippets: in any order, each containing one character out of ``` !"$%&()+,-./:;<>?@[]^_`\|~89ABCDEFGHIJKLMNOPQRSTUVWXYZhjkqwz ``` Explanation: `\len`, which is invoked at the end, converts a control sequence into a string, each character (including `\`) is one character token of that string; then `\glen` gobbles token `\`, then `\tlen` counts remaining tokens. It therefore outputs the length of that control sequence (not including `\`). Characters from other snippets extend the control sequence which is initially just `\t`. A multi-character control sequence has to be made up of letters only, but they all count as letters because they have all been assigned category code 11 (using ASCII codes so that the characters themselves don't appear in the first snippet). I decided to use octal codes for some characters which cost me one symbol, `'` but saved me two digits, 8 and 9, so I gained one snippet. Possibly could have gained a couple more if I didn't need `\expandafter`. Output Possible alteration: wrap `\number\count1` into `\message{}` so the output doesn't go into `.dvi` output but instead to console output and `.log`. It doesn't cost any extra letters. 190 Unfortunately TeX works with ASCII and not Unicode (or does it now?), but my solution could possibly be extended to include 129 more single-character snippets containing the characters with codes 127-255. Maybe even some characters before 32. Character 32 (space) didn't work, otherwise I'd put it into a snippet as well - didn't need it in the first snippet. Of course, each of these additional characters would have to be `\catcode`d into a letter in the first snippet. [Answer] # [Pyth](https://github.com/isaacg1/pyth), 124 snippets ``` l"x00x01x03x04x05x06x07x08 x0bx0c x0ex0fx10x11x12x13x14x15x16x17x18x19x1ax1bx1cx1dx1ex1f !#$%&'()+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkmnopqrstuvwxyz{\|}~x7f ``` [Try it online!](https://tio.run/##K6gsyfj/P0eJkYmZhZWNnYOLm4eLj19AUEhYRFRMXEJSSlpGVk5eQVFZRVVNXUNTS1tHV0/fwNDI2MTUzNzC0sraxtbO3sHRydnF1c3dw9PL28fXzz8gMCg4JDQsPCIyKjomNi4@ITEpOSU1LT0jMys7Ny@/oLCouKS0rLyisqq6prau/v9/AA "Pyth – Try It Online") Unprintable characters where escaped using three printable characters (`x..`). The first snippet is three bytes long, every snippet after that grows in length by one.* [Answer] # [Beatnik](https://esolangs.org/wiki/Beatnik), 22 bytes, score 20 ``` K A E I L N O R S T U a e i l n o r s t u ``` Assuming the word "snippet" allows you to push the value on the stack. [Answer] # Octave, Score 86 ``` nnz n ``` Followed by: ``` !$&()+./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmopqrstuvwxy{\|}~ ``` This exploits the fact that Octave treats everything after a function name as a string input. So `nnz n` returns the number of non-zero elements in the string `'n'`. We get to 86 by adding the other printable ASCII-characters. `',"%#` doesn't work. [Answer] # [APL (Dyalog)](https://www.dyalog.com/), score 12 +1 score thanks to @dzaima* First to third snippets: ``` (~⍴⍬) +≢'a' ,⍕1 ``` Then each of `234567890`. [Try it online!](https://tio.run/##SyzI0U2pTMzJT/8PBBp1j3q3POpdo8kFZ2k/6lyknqiOIaDzqHeqIXZRIxzCxrjETXBKmOKWMcMjZY5PzgKvpCV@WQMA) [Answer] ## Julia 0.6, 111217 The following script creates the full program: ``` A = "macro length(a);length(string(a))end;@length a" B0 = join(([Char(x) for x in Iterators.flatten((0x000001:0x00d7ff, 0x00e000:0x10ffff)) if Base.isvalid(Char(x)) && Char(x) ∉ A && Base.isidentifier("a$(Char(x))") ])); B = normalize_string(B0, stripmark=true, decompose=true); B = join(unique(b for b in B)) while (n = search(B, '·')) > 0 B = B[1:prevind(B,n)]B[nextind(B,n):end] end while (n = search(B, '`')) > 0 B = B[1:prevind(B,n)]B[nextind(B,n):end] end open("concount.jl", "w") do f write(f, A) write(f, B) end ``` ### Explanation The macro ``` macro length(a);length(string(a)) end @length a ``` followed by all distinct unicode characters allowed in identifiers, computed with `isidentifier`. Some diacritial marks mess up counting so I removed them. [Answer] # Pip, 57 bytes, score = 16 ``` !u 2 RT9 #m 5 (EX3Y8) 7 y A'<tab> t 11 +o -v PI@`\...`@`..$` "F"FB:44 Ok=k6 ``` Note that `<tab>` represents a literal tab character (ASCII 9). [Try it online!](https://tio.run/##K8gs@O@mkKYQ/b9asbSWC0gYQcigEEs4QzkXiWmKzNZwjTCOtNDEImSOTawSq6CjOicu8RKcEoaGeKS08/FK6pYRkA7wdEiI0dPTS3BI0NNTSSBNtZKbkpuTlYmWCZna/LNts81q/8cqVHMpBCiEpXHV/gcA) Each snippet is a full program that outputs the desired number. Most of them work on the principle that the last expression in a Pip program is autoprinted: for example, in snippet 5, the previous code is evaluated, but the only part that matters is the `5`. Exceptions to this are: Snippet 3 works fine in isolation as `RT9` (square root of 9), but coming after snippet 2 it actually parses as `2RT9` (2nd root of 9)--which, of course, amounts to the same thing. * Snippet 6 gets the 8th character (0-indexed) of e^3, which happens to be 6. But it also yanks the number 8 into the `y` variable. Snippet 8 then outputs the value of `y`. * Snippet 12 takes the 11 from the previous snippet and adds `o` (preinitialized to 1). Snippet 13 takes that result and subtracts `v` (preinitialized to -1). * Snippet 16 outputs `1` without a newline (`Ok=k`, where `k=k` evaluates to the default truthy value of 1), and then autoprints `6`. Other interesting stuff: * Snippet 14 uses regex operations to extract `14` from the value of pi. * Snippet 15 converts the string `"F"` from hexadecimal. [Answer] # [Zsh](https://www.zsh.org/), score >50 000 (1 112 046?), 16 + Σ(UTF-8 codepoint lengths) bytes ``` exec echo $((${#:-$(<$0)}-33)) # ``` Zsh handles multibyte encodings by default. The base snippet has 18 unique characters, 34 total. Every other codepoint (save for the null byte) can be added onto this. As I write this, my script testing these is on codepoint ~50 000, total file size 150K, going at about 30 snippets/second. [Run my full test script yourself here.](http://ix.io/1SEK) You may want to adjust it to start at some later codepoints. [Try the first 2000 snippets online!](https://tio.run/##TVHPb5swFD7z/opvYK24EVVopWmiIbf2NGmHtZcxDpSYYo3aEXa0rBl/e/ogQdnFsq3v53vvrj2u0WC1wtXD98ero9qrGqpuLQARx@IQZYmIV2Iph@TuTkqKjowj8v3O1JVXSBySFA2RNl69qh6dMrmI/9RIaqzQSKrbqnc5S8U7yYfLMpklIYs2MhwGSY3toaENDunNze1yuRzusbEUzIKJTr8g@fkVtd2oXBS6pMAZvd0q7xasG09xE4Pw17M4jKDoOhpCzrqxRhG9/PWKQ8USMROVt1uPztZVxxdtjYOxb7vO6xFHwSQmopQk0ewyhp/v2b@pD@d@dy33nlPu85Qm7vrzLcJH3TuPMyeDYP9wKurGomIWOxU953/gf6x5GxScpAPdoCh4DdNT4lMOUSwW@xJleQ/fKkNBcPH8cRJFIVyJptKd2oQMeOlV9ZuCRlPQ5Tz28zjYTIb0H/2bMq@@5aiX2KMSYxi9yEV3GueF8GR91Y3rZtq54vED "Zsh – Try It Online") More snippets are possible by using [this technique](https://codegolf.stackexchange.com/a/110724/86147). ]
[Question] [ You are given two strings, each consisting of the English word for a number between 1 and 13: ``` one, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen ``` Your program or function must find out whether it's possible to spell at least one other word from the same list without using any of the letters used in the two input words. You can [follow this link](https://tio.run/##vVFNT8MwDL3zK3xzorWWJk4wFU67wrFCwCFr3TVTl1Rp9oFgv704K9MEPwAfLOfFfu/J3pi9Gapg@5g7X/M4NlCAMhmsNBQP8HkDUAqC3nEG8eAltYGlbvwuSLZ7qQd7lMR7dhmwXbcxA2fPA2ekm37igbvUHVsbIrNDGvrORoUZoF6IUOC4Cw5KGvyWVZX0X4moeichCB8TogzMxBxZV/PxuVGV@Cwgn2uhOI3/5NXvYhKCS6B4KmlrenEnHvHrjBjqTb10tbrTmjbeOoWoBcc3l18i9eEsv74pcM8mqvmt6NyU1PiwNFU7EadzJO1ZkUj@aKQVXvtXl/7rxORKNT/nfQR84QHhHvDJo/5NdErrTA4q7wbfMXV@rYRIL8Zv) to see a naive, ungolfed implementation along with the table of all possible I/O. ### Examples * If the input is `['six', 'four']`, we can spell `'ten'`, `'eleven'` or `'twelve'` so the answer is yes. * If the input is `['five', 'seven']`, we can only spell `'two'` but the answer is still yes. * If the input is `['one', 'six']`, we cannot spell any other number so the expected answer is no. ### Rules * You may take the words in any reasonable format. They can be in either lower case (`'one'`), upper case (`'ONE'`) or title case (`'One'`), but it must be consistent. * You may be given twice the same word. * The order of the words is not guaranteed (i.e. your code must support both `['four', 'six']` and `['six', 'four']`). * You may return either truthy / falsy values (inverting the meaning is permitted) or two distinct and consistent values of your choice. * This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). [Answer] # [J](http://jsoftware.com/), 19 bytes Takes input as `six four`. As the input range is limited, I just deleted characters while the output stayed the same. :-) Reads like "if there is no `e` in the input, or if there are no `t` and `o` in the input, … then we can spell another number." ``` e.e`to`for`si-.~&>< ``` [Try it online!](https://tio.run/##ZY4xD4IwEIX3/oqLA6UJFOOIQkxMnJzcTY6Yq60hNIEKTPx1bMFB43DD@@7evfecN5IrKHLgkMAWcj@phNP1cp5JEjqLyrbYmVROUXmYBaO7thDvlQDemRGUfbX8GyrTE3TUU/ODbeOpGTljVZHHXqEbLDrdEmH4gcHnc0ZcvEjmoR02JhwGWS/UDVT7M6dN64gawdQudCdZrf3YGuk8U8c44cCTm4jKLJug@qzSXO3@VvMb "J – Try It Online") ``` e.e`to`for`si-.~&>< &>< boxing stuff e`to`for`si for each e, to, for, si: -.~ delete from the input any character from the list e. is the input still in the results, i.e. is there any case were no character got deleted? ``` [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes ``` “Œ}İs~#²ð»Ḳḟ@€i ``` [Try it online!](https://tio.run/##y0rNyan8//9Rw5yjk2qPbCiuUz606fCGQ7sf7tj0cMd8h0dNazJBkrWezg937TjWeLjlSFftof0nltY93Lno4c4Wf5NHjVuOTY6wfLh7i@XhiQ93LXi4ewmI3LG45tB@a7A5CgUJCt5AgxQOt4PIhzvbgEgFxCw2NFZw/w8A "Jelly – Try It Online") Adaptation of [xash's J answer](https://codegolf.stackexchange.com/a/215990/66833). Returns a non-zero integer (truthy) for yes and `0` (falsey) for no. The footer generates all test cases and tests them (mapping truthy and falsey to `1` and `0` for readability) My original answer was 38 bytes: ``` “}ICẸƁÄĊ}¿ȥ~ṢṄO4⁴ƓX9Ỵ9ÑẠỤẠḣ\|¿;»ḲiⱮ€Q§Ạ ``` [Try it online!](https://tio.run/##y0rNyan8//9Rw5xaT@eHu3YcazzccqSr9tD@E0vrHu5c9HBni7/Jo8YtxyZHWD7cvcXy8MSHuxY83L0ERO5YXHNov/Wh3Q93bMp8tHHdo6Y1gYeWAyX@ux1uVwHyjk56uHPG///qxZkVCmn5pUXqOgrqaZllqQrFqWWpeSBefh6Qk1kBlgAqgLFBwkAMFwZpUgcA "Jelly – Try It Online") Returns a falsey value if the answer is yes and a truthy value otherwise Basic naive compression approach, ~~I'm sure there's a shorter answer out there that exploits some property that's shorter~~ Both input in the form `six four` ## How they work ``` “Œ}İs~#²ð»Ḳḟ@€i - Main link. Takes s on the left “Œ}İs~#²ð» - "e to for si" Ḳ - ["e", "to", "for", "si"] € - Over each k of these: ḟ@ - Yield s with characters in k removed i - Index of s in this list or 0 ``` And the 38 byte compression version: ``` “}ICẸƁÄĊ}¿ȥ~ṢṄO4⁴ƓX9Ỵ9ÑẠỤẠḣ\|¿;»ḲiⱮ€Q§Ạ - Main link. Takes s on the left “}ICẸƁÄĊ}¿ȥ~ṢṄO4⁴ƓX9Ỵ9ÑẠỤẠḣ\|¿;» - "one two ... twelve thirteen" Ḳ - Split on spaces Q - s deduplicated € - Over each number n: Ɱ - Over each character c in s: i - Index of c in n else 0 § - Sums Ạ - Does not contain 0 ``` [Answer] # [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 23 bytes ``` G`t\|o G`f\|o\|r G`s\|i G`e ``` [Try it online!](https://tio.run/##XZVBktswDATv@wo/YL/g81ZuecImVXTMKkRMyYo3B//dEWYGIOSLPbCAIQSy6bVtffnxfH58bo/x9vF5eYzHun/fHn3/bM/n@Xz69vvPuN36T2un8/ltLO39dOn3RnXr/yTavS2Urf@6bpRLX5S4Xfu6tT1l@xoygGIdJOsgUQc1665ri6WlffGQtGEgIwa0ok6zy/i7youS9dQsp0Y15Szey95Pwx9A7X2G8mWkvUhShkxJg@2r2T09wnx/J3pD0FAyMrxV5VB6AyFZwAAt5AOVoxmWS3p5SJQrQHloH1UmycqHQycqN5KCDzVs4ufYTLSHrTw2Zy/dckh5YBiUM0HBJmbkjZQIzcwYDZWQJypCHqqMdK4ijqMVsU5XLnVMtpdqbXltTW@yc/b9lbKR7OyvM@ZYR06VPyZ3NhmMlRyhkSz5WAgVJgISMQyQ6C@OpwmkTTizdYA0ClOYtfDioAkqp8wHhU2rpAYDAGxM1JwoQQeiiCuIIq57r0qY2Fph@AAXOYdEIRWzoUk5WaULkXOuXBAkKLeCcieKWcDTAQlLuuTTgzX6C1D71PCVZD4DeTOgu1gpOVYrtIaodd@QyFJAXwXwDcxLjtUK@YruntJXkEI6Nf2pYa@rYCZYyY5jlkwnzoXkCXECW1gtmE5CE87KZR2SzVs1LyG/F63eqxHxZrSyeRFgyla3LyLN2coGpnlNs0NVcsybjyjrFgTNcSMSaF2WZJoBsZYWz4zi/5aR/nLlV9PsUMXv/w "Retina 0.8.2 – Try It Online") Link includes all 169 possible inputs. Leaves the input unchanged if no numbers are possible, but outputs nothing if other numbers are possible. Explanation: ``` G`t\|o ``` The input must contain `t` or `o` in order to prevent `two` from being possible; only `two` and `twelve` contain `w`, so if there's a `w` then `t` is already present. ``` G`f\|o\|r ``` The input must contain `f`, `o` or `r` in order to prevent `four` from being possible; only `four` contains `u`, so if there's a `u` then `f`, `o` and `r` are already present. ``` G`s\|i ``` The input must contain `s` or `i` in order to prevent `six` from being possible; only `six` contains `x`, so if there's an `x` then `s` and `i` are already present. ``` G`e ``` The input must contain `e` in order to prevent `eleven` from being possible; only `eleven` and `twelve` contain `l`, only `five`, `seven`, `eleven` and `twelve` contain `v`, and only `one`, `seven`, `nine`, `ten`, `eleven` and `thirteen` contain `n`, so if there's an `l`, a `v` or an `n` then `e` is already present. Additionally, only `two`, `four` and `six` do not contain an `e`, so no other letters need to be tested. [Answer] # [K (oK)](https://github.com/JohnEarnest/ok), ~~28~~ 24 bytes ``` {\|/(x~x^)'$`e`to`for`si} ``` A port of [@xash's excellent J answer](https://codegolf.stackexchange.com/a/215990/98547). [Try it online!](https://tio.run/##bYpRCoMwEESvsoRCFCzqb84iJRQ2zaIkELcq2Hr11FiwFpyPnX0z0159G6NR86vMpmW65fKiUbPXxgfd0zvWq6qk5BvURzht9vCbbGV9nP@gOm32c/CT5k/3xciizKiQAkRelKpRpNa3Ed4h8OiBbUAE458BDA0IPU3Q44AOkB6WwVEaJuy2lEfs1hlbCozoRPwA "K (oK) – Try It Online") [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E), ~~35~~ 34 bytes ``` J“€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿áÓÁÏ“#€SåO0å ``` > > You must compress, > if not, be distressed. > > > Inputs as lowercase. [Try it online!](https://tio.run/##AWEAnv9vc2FiaWX//0rigJzigqzCteKAmuKAouKAnsOt4oCgw6zLhsOIxZLFocOvwr/FuMKvwqXFoOKAlMK/w6HDk8OBw4/igJwj4oKsU8OlTzDDpf//WyJzaXgiLCAiZm91ciJd "05AB1E – Try It Online") # How? ``` J # Join the two input numbers into a string “€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿áÓÁÏ“ # Push the number words from "one" to "thirteen" Så # Are each character in the input?numbers? 1 if yes, 0 if not € O # Sum the results for each word 0å # Is there a 0 on a word? # (implicitly) Print the answer ``` [Answer] # [Japt](https://github.com/ETHproductions/japt) [`-x`](https://codegolf.meta.stackexchange.com/a/14339/), 14 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) Adaptation of [xash's J solution](https://codegolf.stackexchange.com/a/215990/58974) so be sure to upvote them, too. Input as a single lowercase delimited string, outputs a positive integer for true and `0` for false. ``` `èJ-n£`qÍ£¶kX ``` [Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LXg&code=YOiBSi1uo2BxzaO2a1g&input=InNpeCBmb3VyIg) or [try all possible pairs](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=YOiBSi1uo2BxzaO2a1g&footer=Tm1nViCuuPo4ILjDcFV4IGcpcSIgLT4g&input=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) (with `1` used for true) [Answer] # [Python 3](https://docs.python.org/3/), 67 bytes ``` lambda s:sum(max(c in p for c in s)for p in'e to for si'.split())<4 ``` [Try it online!](https://tio.run/##lZbdTttAEIXv8xQrbmxLaUUKUiXU9EWAizRsGoslsewB0kY8e5qdOTM7DkSiWEjnrOfnQ7Ni3P2h9XZzdVjN7w5p8fTrYRGGm@H5qX5a7OplaDehC6ttH1gOTZbdUVYx0JZfDG31dehSS3XT/Lg@UBxomNe3F9tNDMffiykret2qWvdRT1fb515l@6KnQ7tTFV/iBjq2v9cEvWlL4RKQXDS9xmQFad32FPndkQNUWQkVK1BlDSqWQpWlULFCn6yVKmtQcbkSkFy0UUnLQpW7KxdrkIlWNnZKJwZ8bEAoWruyM0p2yinFfVgaZRVaYBhvZgAuS6EVCVg2YBUtqKyFVCRaslFONsCUqi4m@QxjRPOCeGyniFkCkaUiZqOIrIGYNRBZasNsDDEbReSqLib5jIIozQ3x2AKEWQkgK/BlDTyWQpelwLFCp6wVLWuQcbkSkFy0YUnLQpVjlIs1yEQrGzulEwM@NiAUrV3ZGSU75ZTiPiyNsgotMIyX64FXtPBCg1cceGGEV4zwQqOzOOUVB14U92FplGW8imG8uQJwWQqtSMCyAatoQWUtpCLRko1ysgGmVHUxyWcYI5qXf0d2AcjGT274VEZPZfBkYyc3dHIjpzJwsnGTHzb5UdPJoJO7mTAYdRrdTVgddvK3Ew7jTqP7CWsDT/6Gao9RZBpnlqGn01sqr2z1sNHtI8YWEFvbQeJ0DbHTTSTG1gvbso/Y2kqSHqPINM50uwlAbj2JtA0Fq0tKre0pHNiqUq/bCl4XllrbPjgoawsHtrm040l8Oq3gVphB4s@6byZx18UlxYd5PZvKc2mP@plT5958Pud9pI8pmbOz1T96c/kfOe/Vx/5zOWefZrJcx@Vj7MM81NXd87fv18tqGljNrqpmkj8daRrzV@Xftqv5s3EadCLNzSQcf3L2qqaGTde3G6pX1Z7ewpefYd@/hT2a3Mb5vL9/q5rDPw "Python 3 – Try It Online") Uses [xash](https://codegolf.stackexchange.com/users/95594/xash)'s idea from his [J answer](https://codegolf.stackexchange.com/a/215990/9481). [Answer] # [C (gcc)](https://gcc.gnu.org/), ~~130~~ ~~128~~ 102 bytes Saved 2 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!! Saved a whopping 26 bytes thanks to [AZTECCO](https://codegolf.stackexchange.com/users/84844/aztecco)!!! ``` a,b,i;f(s,j)chars,j;{for(a=b=0,i=11;i--;i%3\|\|(b+=!a,a=0))for(j=s;j;)a+="e..to.forsi"[i]==j++;b=b;} ``` [Try it online!](https://tio.run/##lZbRbtpAEEXf@xUOEpIBk0KjPlSu@1L1KxIejLME0y1EeJugJvx66e7Mndk1SaQ0FtK969mZQ2aT2WZ61zSnU10si7Zc5V2xGTXrej/uivGmfFrt9nldLatZ0VbzedlOp2U7vHp@zpeT6qIu6mo2GoWYTdWVPn5UT6qBubx0u0u/2rWD63ZRVePNZFIuq2V5PP2q220@yp4@ZP6H6mTOdK67XmRV9jTYbU3mP4OClHvciVrvjayudr/3ItsHWe3agyjzYLbQpr1bO@htGxPHAJtEu0djNaFbt3tn6J3nAFVQTEUKVEGDiiRTBclUpFAnaKEKGlSULgbYJFqpuGSkCtWFizTIWAsbOaFjAz4yIGQtVckpJTnh5ORpmO3tirTAUN7AAFySTMsSsGTAyppRSTMpS5QkI5xkgMlZkxib7lBGFI@IvpwgBglEkoIYjCCSBmLQQCQpBYNRxGAEkbImMTbdERG5uCL6EiAMigFJgS9o4JFkuiAZjhQqBS1oQYOM0sUAm0QrFpeMVCFGuEiDjLWwkRM6NuAjA0LWUpWcUpITTk6ehtnerkgLDOWlfOBlzbzQ4GUHXhjmZcO80KjMTnjZgRfJ0zDb26W8gqG8IQNwSTItS8CSAStrRiXNpCxRkoxwkgEmZ01ibLpDGVE8/jvSA@C0/S5pvoutd7HxTtvukqa7pOUuNtxpu13abJe22p012iYnEwattr2zCSvNtunphEO7be98wmrDbXpCpUYv0vZ3xqbb81PKr3T0kJHpw0YHEFmdQexkDJGTScRGxwvZOI/I6kjiGr1I29@ZzCYAJeOJpU4oWBlSYnVOYUFHlXiZVvAysMTq9MFCHFtY0MklFc/i7XmGZIQpJL7WsaSLS7v1f7uHe9M4c8s3l3nBz0wf8fNEvfXm/XteRqYxcef8zeyvvZn9x56X6nX/vj1vPvhN8xWxWZvmp9njknhz@PHp5vDlu/98HhRZ6q@kQ/72meWhTe321hz8tlkJ@dWfoD9mt8qlgaOPWBjrSplNJhQtN9Xktupz8Y2VAhalvg/VOv/24mKVu1F/3fh1PTDnG@/3PmSVD4ZdNv2WDW@zYXfjD2Tmiqwr9LubquoWSHv8cDz9bVa2vutO08d/ "C (gcc) – Try It Online") Uses [xash](https://codegolf.stackexchange.com/users/95594/xash)'s idea from his [J answer](https://codegolf.stackexchange.com/a/215990/9481). Inputs a string of two words separated by a space and returns a truthy value if it's possible to spell at least one other word from the given list without using any of the letters used in the two input words or a falsy value otherwise. [Answer] # [Perl 5](https://www.perl.org/) `-p`, ~~83~~ ~~28~~ 26 bytes Credit to @NahuelFouilleul for saving 2 bytes ``` $_=/e/&/t\|o/&/[for]/&/i\|s/ ``` [Try it online!](https://tio.run/##DcYxCoAwDEDRvafoIG7SydGTiDilGChJSWLt4NmNXf77FaSs7tO5JUhzspdH98xyDPHV5K7YY@ZbQsYGUaEBBaZx2INdKAZA0R7@uBoyqS@1/A "Perl 5 – Try It Online") Switched to @xash's method. This script inverts the output: `0` means that another number can be formed; `1` means that another number cannot be made. [Answer] # [Python 2](https://docs.python.org/2/), 56 bytes ``` lambda s:all(set(x)&set(s)for x in"e to for si".split()) ``` [Try it online!](https://tio.run/##VY/BCsIwDIbP9ilCD9Iy8OBR2BtsTzA9dJi6Qm1HG7f59LPZQPGU5Oufj3R80xDDebX1dfXm2d8N5IvxXmUktegjl6xtTLCACxKBIvCUnTzl0TtSWq9NLWMoT3MEGhJiSbwSWDdhyS2QccIA6B4DQXAc5NFvlGb0JUaDS4QYvlIhxuQCKaskK1gotf7BXc6KP8xnlDwz0dZdV1llKgmy6vV2timfgObGbb@3@64QjBKj9iIOuy/p9QM "Python 2 – Try It Online") Take inputs like `two four`, outputs negated. Checks whether the string has an `e`, and intersects the non-`e` numbers of `two`, `four`, and `six`. [52 bytes in Python 3](https://tio.run/##VY/BCsIwDIbP9ilCD9I68OJN2BvoE0wPHaauUNvRRjcZPvtsHCjeki9/PpL@SV0Mu9nWp9mbW3sxkPfGezVtxtd62uSXjQlGcEEiUATuspPb3HtHSuv5UMsYymiIQF1CLIl7AuseWHIjZHxgAHTXjiA4DnLrP5QG9CVGnUuEGL5SIfrkAimrJCtYKLX@wUXOij/MZ5Q8M3Gsm6ayylQSZNXqz9mmPAGHM5ftUi67QjBKjI57sVp8Sc9v) using `{x}` for `set(x)`. [Answer] # [Bash](https://www.gnu.org/software/bash/), ~~85~~ ~~74~~ ~~61~~ 53 bytes Supply the input as an argument of the program. Output is via exit code. ``` [[ -z `for i in e to for si;{ grep -v [$i]<<<$1;}` ]] ``` [Try it online!](https://tio.run/##FccxDoAgDAXQq/yBlcGZ3oQ0QZOiXcBQw6Dx7DW@7W2rHe45I94otQ8otEFwdfwzTQ/2ISfiRA7KRBSW9BYwu3vVKTCZ0j4 "Bash – Try It Online") [Answer] # [Python 3.8 (pre-release)](https://docs.python.org/3.8/), ~~175~~ ~~164~~ 146 bytes ``` def f(x):w="oe two tre for fie si se eit ie te e twe tire".split();return[[(w:=[filter(lambda a:c not in a,w)])for c in i]for i in x][-1][-1]!=[] ``` [Try it online!](https://tio.run/##XYzLCsIwEEX3fsWYVSJVEDdS6ZeELGo7wYGalMn04dfXRBeCiwvncubO@JJHDJfryNvWowevV1MvjYoIskQQRvCRwRNCIkgISAK5SKZ8kUOM6pTGgUSbG6NMHKzVS93Yg6dBkPXQPu99C23dQYh5HaCtFuNMedyVSq4gFVydPZ4/2TfWbSNTEO21VYlWVYHycWLljNn9jKcZi0o4Y/hzMXxVHmexvQE "Python 3.8 (pre-release) – Try It Online") saved 8 bytes with the help of member [SunnyMoon](https://codegolf.stackexchange.com/users/98140/sunnymoon) saved 18 bytes with the help of member [Neil](https://codegolf.stackexchange.com/users/17602/neil) normal version of the code: ``` def f(x): w="oe two tre for fie si se eit ie te e twe tire".split() for i in x: for c in i: w = [filter(lambda a:c not in a, w)] return w != [] ``` [Answer] # [Charcoal](https://github.com/somebody1234/Charcoal), 19 bytes ``` ⊙⪪”&↓εg⌕⁸¡⁼”a⬤ι¬№θλ ``` [Try it online!](https://tio.run/##FcoxCoAwDADA3VeEThHqC5yKuwi@IEjFQGi0RsHXR735lo3qoiTuU@VimMqD8y5sGDKZ0qqVTg4RAoU2QhJBjjCq4aDX948I0v5695XvDJZL490tLw "Charcoal – Try It Online") Port of my Retina answer, but I was able to output a Charcoal boolean, i.e. `-` for possible, nothing for impossible. Explanation: ``` ”&↓εg⌕⁸¡⁼” Compressed string `eatoaforasi` ⪪ a Split on `a` ⊙ Any substring satisfies ⬤ι All characters of substring satisfy ¬№θλ Character not present in input Implicitly print ``` [Answer] # [Ruby 2.7](https://www.ruby-lang.org/) `-n`, 45 bytes +1 to the idea of [xash](https://codegolf.stackexchange.com/users/95594/xash) in his J's answer!* ``` p %w[e to for si].any?{$_.chars&_1.chars==[]} ``` [Try it online!](https://tio.run/##JYo7CoAwDED3niKDuukNxIMUEZWKWZLS1B/WqxsLDo/3hhe26VL1UB7WQWRYOIBg34x0dXeSVAzNvI5BKvndtrZ/VAXPvG7BLLg7ELc7Mky58DTxYMi87CMyidb0AQ "Ruby – Try It Online") # [Ruby 2.7](https://www.ruby-lang.org/) + `gem install humanize`, 61 bytes ``` require'humanize' f=->v{(1..13).any?{_1.humanize.count(v)<1}} ``` [![gem-install-humanize-demo](https://i.stack.imgur.com/sG0fy.png)](https://i.stack.imgur.com/sG0fy.png) # [Ruby 2.7](https://www.ruby-lang.org/) `-n`, ~~104~~ 90 bytes Saved 10 bytes by removing duplicate chars from number names. ``` p %w[one two thre four five six sevn eight nie ten elvn twelv thiren].any?{_1.count($_)<1} ``` [Try it online!](https://tio.run/##JY3BCgIxDETv/YocFPTggnfBDxERlawbkGRp03YX1183pnoaZph5E/NtNhthXU/CCFoFdIgIveQIPRWERBMkLAxIj0GByVvo7umRVhcfUEQ@d1eej68lLam7S2bdrC7bw/5t1giNF/48LMihnXkefodVPjIqCSfb8Rc "Ruby – Try It Online") TIO uses an older version of Ruby, while in Ruby 2.7, we've numbered parameters, i.e., `_1`, which saves 2 bytes. [Answer] # [Jelly](https://github.com/DennisMitchell/jelly), ~~39~~ 37 bytes ``` ị“½ĠWufṠ`ßṡƝ0:Ƒ’bȷ¤æ» OUḅ96%191%⁵)ç/Ḃ ``` [Try it online!](https://tio.run/##AVoApf9qZWxsef//T1XhuIU5NiUxOTEl4oG1CuG7i@KAnMK9xKBXdWbhuaBgw5/huaHGnTA6xpHigJliyLfCpMOmwrsKw5HigqzDpy/huIL///8ib25lIiwgInNpeCI "Jelly – Try It Online") -2 bytes thanks to @xigoi Takes input as a list of two words in lowercase. ### How it works Uses a lookup table for all pairs. Instead of a 13×13 lookup table, this uses a 10×10 table because a few number/words (1&3, 2&4, 7&9, 10&12) have the same table values, so I engineered a hash with very specific collisions using a [brute force script](https://tio.run/##xVRPb5swFL/zKd5aJTWJ12LI0iZSjutxOzS3CFUGnGKNGGSbtNG06z5AP@K@SGYbCE1Vqelhmg8WPP/@vOfHo9rpvBTRfn/@6apW8irh4oqJLVRN3FvLcgPrWqS6LAsFfFOVUoNkWZ0yr31TO@WdQ1oWBVe8FGoOZBhhCIcTDNfDGQYSDEnoGYxkupaipaOCbpKMwhPezZ9GO7wqZYZSf3wN61JCClyAiv1BFE4H5MupZBIds0NCPsB@ZT0hwYBEp5LD2Sv2dDYwZR/Y6A362NAnk9GIjxoRp8Cx02Ci3jBJNUNqNZ9/JrEf@/5gdm1E4c/vZzhB@ib6kPSkkyb/VXo2fVfaiZKZ6W3gVAPPy9gacqQwUAwJhsyfe2DWO17ZaVZ0kDQOXN1vacEzlFOV39vBwJBSxQ5uqi60ggX8NGNwwBgVp66stoX/cugN1WnOxcN9Rbm0pBWyh6sgbkRXYexjaGKki0V9bNrFbvrYrIsRe/XORpeaFka9YAIpplGb5KUppGYK@b7vYDZBe3c2x@PMmtrs4uuuxBWNYbE4vCVxD@o9xwvT7xddaDMx0cjzbJauaIe4KAXDoB9Ls@WSmed1WUuz8615VvzJbGzLBAbGH3KNQXBHcJGiOdGPrLBonXOpGRMX@N9JX9ZVxSTyW4vvlrG0FsvG4tZZ3DqLO2tx1wh9bSy@OYuli7QWy9Zi2Vl4sZeZ1M0V3dJCMc82yHVHUvHAkP2xRu13Z/pioX0PEsnoj0Nbs54VYhIEfg90Xe@PkzHBEB0hOhRvPqzj8XBNfAVuEzqMSjtzdiBezmcjd6mqgmt0huHMf0PHrkpyoVHWMbn/Jqq9qqWs2X7/Fw). A 9×9 table is theoretically possible, but I doubt that it will save bytes due to a more complex hash function. [Lookup table generator](https://tio.run/##vZM7b9swEMd3fYrbSMJnwo7zcm2lSIEMXdrRKFQNskzFVBVSoOg8kPizO0cqju0lYzUcpOPd738Pqi4ei650uvVDY1dqt6sgBV4gLAWkN/CaACzIw6xRCP7Jklk7Re@V3Tiy@pHeO/1MRj0qg6D0/dojGB0ToqfpT/yTakK0X2vnlTJMdm2jPWcITMxIyCm/cQYWsrMPipdBP5NSlrkkgHvpPbyAARUntVmp598VL6nOFIZjQYjt7j/VmjjVkVJ2jTBC6O0FwhnCFOEcYYwwQbiK9jJPGmv/bdqQQO3cOle88PFI5PKhaLlKb0YiSSrrgDfKg05HM9Dz8YTsYCDiBoK/td0tEUg403mYlq4oIYKzcJYLKK3x2mxUOP3k1YFXR169530Sf3wQ60gk9xEP3lKo@ILUEBYUIWA@jzkUuU22Cal1tlGysfcfdVAbcTI/Da2rU8R@3X7d2CE46xvLKUkTPInjHeEYz3CC53iBl3iF1zjNE7vxYcmwfxjdhy6Osgj3g71FzyI7Yhd5LttidWdWfCqErK02nDFBYeyvGe6fkMYGw8O3dKpVhQ@7miWdpE7uinLdy4TqQyWDNDC@VgyzPaQv9@kHQF8yD9M@ZeApdZnTFr4D@6M6Bt@A/bJMnMpsw18QLujxdkhGzHbv) after computing the hashes. ``` OUḅ96%191%⁵ # hash function OUḅ96 # character codepoints interpreted in reverse as a base 96 number %191%⁵ # mod 191 then mod 10 ị“½ĠWufṠ`ßṡƝ0:Ƒ’bȷ¤æ» # lookup table ị“½ĠWufṠ`ßṡƝ0:Ƒ’bȷ¤ # get the correct row from a list of 10 rows corresponding to the hash of the first word # (base-250 compression then interpret as base 1000) æ» # bitshift by the amount corresponding to the hash of the second word Ñ€ç/Ḃ # apply the lookup table and hash. For some reason I couldn't get ÑçÑḂ to work. ``` [Answer] # [Husk](https://github.com/barbuz/Husk), ~~14~~ 12 bytes Edit: -2 bytes thanks to Razetime ``` Λn⁰w¨toƒr¹∫e ``` [Try it online!](https://tio.run/##yygtzv6f@6ip8f@52XmPGjeUH1pRkn9sUtGhnY86Vqf@//8/Wqk4s0IhLb@0SElHKS2zLFWhOLUsNQ/Iyc8DsjMrlGIB "Husk – Try It Online") Outputs falsy (`0`) if we can spell another letter without the input letters, truthy (non-zero) otherwise. Uses approach of checking whether any of the input letters are present in `"to"`, `"for"`, `"is"` or `"e"`, as pioneered by [xash's answer](https://codegolf.stackexchange.com/a/215990/95126). ``` Λ # are all these elements truthy? n # are there intersecting elements of ⁰ # input # in each of w¨toƒr¹∫e # "to","for","is","e" ``` [Answer] # [Zsh](https://www.zsh.org/) `-Fe`, 30 bytes ``` for i (e to for si)grep [$i] f ``` [Try it online!](https://tio.run/##3VhNb9swDD3Hv4JIC6wFlvW@od2tQE@77DYMiFczsVBFMiQ66frnM5GUnHY/gUHiPEnUE5/14Qe/5fF8BT7GCeIRE/Teg3cBM7hQvtNM3Wl0HiFhP4D/BkPsutUVTCnuU38A6l8ktgRCn6GHXQn@DDnCKTlCoCg18NSt8HmMcO3hAR6FAg@z70tImkNwYQ8xwHM8HPowSAbl8oKwfcsjbB6xNA34hQvrWNrKb71lkj/43M8Z4efTj5Ia5vCJIM/TFBNBnMjFkCvRBrewiwmY4@tNtyrfVUZi8jPXO7jRdAvO7nafcIJf1@43PJ7LOG4fYkLINMSidAM0chL@L5Qiaz8hnPpA4LI04asjSblb3cLD3YDHuzB7X2@dK4H/RbWbs75/WMP1924oCs9VKVj6dCyITtGgqDEhWhO1i3MyN1M7d0RzorJ7tbenMh4xWBOFbj@SNVHBBXt7ikwtvrb8vK1NVR0FekuHenUULhHamauOfZ857yeirHk/FmXO@4koa96PRZnzfiLKmvdjUea8H4sy5/3kSLfm/WT5WfN@6iiMeT91FNa8n1gkW0apirJllJooZ2tPiShbRqmJMnWmV1G2jFIVZcsotSPdmEvX5WfKKLWZMmWUFkdhySh14iWMvXmpomy9eVFRxt68VFF89imUx7BCfngpoqXVXyL1cKm47slO5pwvisrdqkD7MawjMNQRGNHS6i@RbQTBbQSeAKaVf4llpKSMhJMBtSa/RFVCgQufnPuVSXDlEqxsAukS4N9FN04tNFZ1M8qkWJgU0iVAmWq1MtVCYxILIZ0FUauqXbVSeypuHanmTJeM6ZIvfcjWv9dVSy0d/1FZfaY0mlpaWtvhvNT8Aw "Zsh – Try It Online") (includes all combinations) Takes [input from a file](https://codegolf.meta.stackexchange.com/a/2452 "although it's somewhat controversial") named `f`, outputs via [exit code](https://codegolf.meta.stackexchange.com/a/5330) (`0` = we can't spell a third word, `1` = we can). The option `-F` disables globbing; without it, we would have to escape the square-brackets. `-e` makes `zsh` exit on the first command that fails - it's like a short-circuiting NOR over all the commands executed, similar to the approach in this great [J answer](https://codegolf.stackexchange.com/a/215990). Also takes inspiration from this [Bash answer](https://codegolf.stackexchange.com/a/216040). [Answer] # [Haskell](https://www.haskell.org/), 44 bytes ``` f a=any(not.any(`elem`a))$words"e to for si" ``` [Try it online!](https://tio.run/##NctBDoIwEAXQPaf4aVhAQG@AJ9CVS2OkidPQCB3SGUBPXyuJm/lvJn8GKy8ax5QcbGfDpwqsx1/2NNLU27ouN45PMQRlOI4Qb5KSKKSbF71qPAeUEDQNDA6nPLJk4A2Vg9RFMVkf0GGy8@WB/fNmOFCrG5t2l/h3Vt5bx0vMzIc/nV9zgVYK5p6@ "Haskell – Try It Online") * Uses [xash](https://codegolf.stackexchange.com/users/95594/xash)'s idea from his [J answer](https://codegolf.stackexchange.com/a/215990/9481). * Takes input as "one,two" and returns True for yes, False for not. * I think it reads well as it is so no explanation. [Answer] # [R](https://www.r-project.org/), 87 bytes ``` function(x,u=utf8ToInt)all(sapply(c('to','for','si','e'),function(m)any(u(m)%in%u(x)))) ``` [Try it online!](https://tio.run/##bY0xCsMwEAT7vMIYjE6gB6TxA9KnN8JIRKDcCenOyK9XLk0g4C1mi2HZOnaPvLUSct48Er9CXUcU3DkRQneyCsf7kx7I1ucMzZeST9jBMBlnIlVlS4pgrPsN39bjCaK9JFwEutV8v/6vYG6pT5GkzvZ2YWM6wtTCEfDaE6pOXeX4AA "R – Try It Online") Reversed output: `TRUE` if we cannot spell another number without the input letters. Started with the full vector `"one","two","three" ... "thirteen","fourteen"`, then removed the duplicate letters, then removed the only-in-one-number letters, then removed the letters in words that consistently had another letter. This brought the vector to `"oe","to","tre" ... "e","te","tire"`. At this point it was obvious that we can delete all numbers containing an "e" except `"e"` (which is what's left of `"eleven"`). And then I realised that I'd just re-created [xash's answer](https://codegolf.stackexchange.com/a/215990/95126). Well done, [xash](https://codegolf.stackexchange.com/users/95594/xash)! [Answer] # [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 14 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) ``` “e€‡€ˆ€„“#€мQà ``` Port of [@xash' J answer](https://codegolf.stackexchange.com/a/215990/52210), so make sure to upvote him! Also takes the input as a single (space-delimited) string. [Try it online](https://tio.run/##yy9OTMpM/f//UcOc1EdNax41LASSp9vAzHlAQWUg68KewMML/v8vzqxQSMsvLQIA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXL/0cNc1IfNa151LAQSJ5uAzPnAQWVgawLewIPL/iv8z9aqTizQiEtv7RISUcpLbMsVaE4tSw1D8jJzwOyMytAwkBZMDMWAA). Explanation: ``` “e€‡€ˆ€„“ # Push dictionary string "e for is to" # # Split it on spaces: ["e","for","is","to"] €м # For each: remove all those characters from the (implicit) input Q # Then check for each if they're still equal to the (implicit) input à # And check if any of the four were truthy by taking the maximum # (after which this 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 `“e€‡€ˆ€„“` is `"e for is to"`. [Answer] # [JavaScript (Node.js)](https://nodejs.org), ~~99~~ ~~95~~ 78 bytes ``` x=>y=>!'e to for si'.split` `.filter(m=>![...m].some(k=>(x+y).includes(k)))[0] ``` [Try it online!](https://tio.run/##ZY69TsQwEAZ7nmKp1tYFixopKa@9ghKQYuXWaDnHjrxO5Dx9iOFO4qf8RjPa/bCLlSHxlB9CPNPm2q203dp290iQI7iYQBiNTJ5zD71x7DMlNe7GeKW9Ge2kLm2nymHVhsPg5zOJuugfI6eZtH55fNuGGCR6Mj6@KzxaLwQj2SCwkjRQvesO8TWgvvvlP3Np9qfm9IRwAKdQuKBWWBFq@GMfeaEGhBYKN9/tqAZf8H9xCjXgctNj@LbrFdDbJw "JavaScript (Node.js) – Try It Online") Uses xash's idea from his J answer. Returns false for yes and true for no (counterintuitive I know, deal with it). Uses currying syntax - `(x)(y)`. Explanation: ``` x=> //declare function y=> //declare function 2 ! // necessary for consistent result 'e to for si' //see xash's J answer .split` ` // to array .filter( //keep value only if following true m=> //function with value m ! //if following is false [...m] //m into array of letters .some( //replace each with k=> //function of k (x+y).includes(k) //if includes true (input contains one of word ) ) // array now has any items only if it contains something [0] //0th item, undefined if no answers, one of strings above if does, then negated by ! at top. ``` There's got to be a better way to do all the .includes. # Regex (any) ``` ^([^e]\|[^to]\|[^for]\|[^si])$ ``` Just using @xash's trick again. Takes a single string. # Javascript, 44 bytes (using regex) ``` x=>/^([^e]\|[^to]\|[^for]\|[^si])$/.test(x) ``` I mean it works, but I like the other one because it took more than 2 minutes. Takes a single string. ]
[Question] [ Your job is to create the slowest growing function you can in no more than 100 bytes. Your program will take as input a nonnegative integer, and output a nonnegative integer. Let's call your program P. It must meet the these two criterion: * Its source code must be less than or equal to 100 bytes. * For every K, there is an N, such that for every n >= N, P(n) > K. In other words, [lim(n->∞)P(n)=∞](https://en.wikipedia.org/wiki/Limit_of_a_sequence#Infinite_limits). (This is what it means for it to be "growing".) Your "score" is the growth rate of your program's underlying function. More specifically, program P is grows slower than Q if there is a N such that for all n>=N, P(n) <= Q(n), and there is at least one n>=N such that P(n) < Q(n). If neither program is better than the other, they are tied. (Essentially, which program is slower is based on the value of lim(n->∞)P(n)-Q(n).) The slowest growing function is defined as the one that grows slower than any other function, according to the definition in the previous paragraph. This is [growth-rate-golf](/questions/tagged/growth-rate-golf "show questions tagged 'growth-rate-golf'"), so the slowest growing program wins! Notes: * To assist in scoring, try to put what function your program calculates in the answer. * Also put some (theoretical) input and outputs, to help give people an idea of how slow you can go. [Answer] # [Brachylog](https://github.com/JCumin/Brachylog), 100 bytes ``` llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll ``` [Try it online!](https://tio.run/##SypKTM6ozMlPN/r/P4cO4P9/Q4PBAf5HAQA "Brachylog – Try It Online") This is probably nowhere near the slowness of some other fancy answers, but I couldn't believe noone had tried this simple and beautiful approach. Simply, we compute the length of the input number, then the length of this result, then the length of this other result... 100 times in total. This grows as fast as log(log(log...log(x), with 100 base-10 logs. [If you input your number as a string](https://tio.run/##7daxDYAwEATBXlwBUA4ZEEBgCYmM6o8ujAXjCsb3ya7Xsh13PfcpqQ1eUsbh9dcBgYPjNw57cnBwcHT49BgHhx6zJwcHB4ceMwUHhx7j4ODg0GN25eDQY/bk4ODg0GMcHBx6jIODg0OPuS8Hhx6zJwcHB4ce4@Dg0GMcHBwcesx9OTj0mD05ODg49BgHB4ce4@Dg4NBj7svBocfsycHBwSHHODg45BgHBwfH93NMj3Fw6DF7cnBwcPiU@3Jw6DEODg4OPWZXDg49Zk8ODg4OPcbBwaHHODg4OPSY@3Jw6DF7cnBwcOgxDg4OPcbBwcGhx9yXg0OP2ZODg4NDj3FwcOgxDg4ODj3mvhwcesyeHBwcHK1eyfwA), this will run extremely fast on any input you could try, but don't expect to ever see a result higher than 1 :D [Answer] # Haskell, 100 bytes, score=[fε0](https://en.wikipedia.org/wiki/Fast-growing_hierarchy)−1(n) ``` _#[]=0 k#(0:a)=k#a+1 k#(a:b)=(k+1)#(([1..k]>>fst(span(>=a)b)++[a-1])++b) f n=[k\|k<-[0..],1#[k]>n]!!0 ``` ### How it works This computes the inverse of a very fast growing function related to [Beklemishev’s worm game](http://www.mi.ras.ru/%7Ebekl/Problems/gpa5.html). Its growth rate is comparable to fε0, where fα is the [fast-growing hierarchy](https://en.wikipedia.org/wiki/Fast-growing_hierarchy) and ε0 is the first [epsilon number](https://en.wikipedia.org/wiki/Epsilon_numbers_(mathematics)). For comparison with other answers, note that * exponentiation is comparable to f2; * iterated exponentiation ([tetration](https://en.wikipedia.org/wiki/Tetration) or [↑↑](https://en.wikipedia.org/wiki/Knuth%27s_up-arrow_notation)) is comparable to f3; * [↑↑⋯↑↑](https://en.wikipedia.org/wiki/Knuth%27s_up-arrow_notation) with m arrows is comparable to fm + 1; * The [Ackermann function](https://en.wikipedia.org/wiki/Ackermann_function) is comparable to fω; * repeated iterations of the Ackermann function (constructions like [Graham’s number](https://en.wikipedia.org/wiki/Graham%27s_number)) are still dominated by fω + 1; * and ε0 is the limit of all towers ωωω⋰ω. [Answer] # JavaScript (ES6), Inverse Ackermann Function\, 97 bytes \if I did it right ``` A=(m,n)=>m?A(m-1,n?A(m,n-1):1):n+1 a=(m,n=m,i=1)=>{while(A(i,m/n\|0)<=Math.log2(n))i++;return i-1} ``` Function `A` is the [Ackermann function](https://en.wikipedia.org/wiki/Ackermann_function). Function `a` is supposed to be the [Inverse Ackermann function](https://en.wikipedia.org/wiki/Ackermann_function#Inverse). If I implemented it correctly, Wikipedia says that it will not hit `5` until `m` equals `2^2^2^2^16`. I get a `StackOverflow` around `1000`. Usage: ``` console.log(a(1000)) ``` # Explanations: ## Ackermann Function ``` A=(m,n)=> Function A with parameters m and n m? :n+1 If m == 0, return n + 1; else, A(m-1,n? :1) If n == 0, return A(m-1,1); else, A(m,n-1) return A(m-1,A(m,n-1)) ``` ## Inverse Ackermann Function ``` a=(m,n=m,i=1)=>{ Function a with parameter m, with n preinitialized to m and i preinitialized to 1 while(A(i,m/n\|0)<=Math.log2(n)) While the result of A(i, floor(m/n)) is less than log₂ n, i++; Increment i return i-1} Return i-1 ``` [Answer] # Pure Evil: Eval ``` a=lambda x,y:(y<0)x or eval("a("999+"x*.1"+",y-1)"999) print a(input(),99999)//1 ``` The statement inside the eval creates a string of length 7\[1010101010108.57](http://www.wolframalpha.com/input/?i=(9%5E9%5E9%5E9%5E9)%5E(9%5E9%5E9%5E9%5E9)%5E(9%5E9%5E9%5E9%5E9)) which consists of nothing but more calls to the lambda function* each of which will construct a string of similar length, on and on until eventually `y` becomes 0. Ostensibly this has the same complexity as the Eschew method below, but rather than relying on if-and-or control logic, it just smashes giant strings together (and the net result is getting more stacks...probably?). The largest `y` value I can supply and compute without Python throwing an error is 2 which is already sufficient to reduce an input of max-float into returning 1. A string of length 7,625,597,484,987 is just too big: `OverflowError: cannot fit 'long' into an index-sized integer`. I should stop. # Eschew `Math.log`: Going to the (10th-)root (of the problem), Score: function effectively indistinguishable from y=1. Importing the math library is restricting the byte count. Lets do away with that and replace the `log(x)` function with something roughly equivalent: `x.1` and which costs approximately the same number of characters, but doesn't require the import. Both functions have a sublinear output with respect to input, but x0.1 grows [even more slowly](http://www.wolframalpha.com/input/?i=log(10,x),x%5E0.1where+x+from+0+to+1000). However we don't care a whole lot, we only care that it has the same base growth pattern with respect to large numbers while consuming a comparable number of characters (eg. `x.9` is the same number of characters, but grows more quickly, so there is some value that would exhibit the exact same growth). Now, what to do with 16 characters. How about...extending our lambda function to have Ackermann Sequence properties? [This answer](https://codegolf.stackexchange.com/questions/18028/largest-number-printable/18359#18359) for large numbers inspired this solution. ``` a=lambda x,y,z:(z<0)x or y and a(x.1,zz,z-1)or a(x.1,y-1,z) print a(input(),9,99999)//1 ``` The `zz` portion here prevents me from running this function with anywhere close* to sane inputs for `y` and `z`, the largest values I can use are 9 and *3* for which I get back the value of 1.0, even for the largest float Python supports (note: while 1.0 is numerically greater than 6.77538853089e-05, increased recursion levels move the output of this function closer to 1, while remaining greater than 1, whereas the previous function moved values closer to 0 while remaining greater than 0, thus even moderate recursion on this function results in so many operations that the floating point number loses all significant bits). Re-configuring the original lambda call to have recursion values of 0 and 2... ``` >>>1.7976931348623157e+308 1.0000000071 ``` If the comparison is made to "offset from 0" instead of "offset from 1" this function returns `7.1e-9`, which is definitely smaller than `6.7e-05`. Actual program's base recursion (z value) is 101010101.97 levels deep, as soon as y exhausts itself, it gets reset with 10101010101.97 (which is why an initial value of 9 is sufficient), so I don't even know how to correctly compute the total number of recursions that occur: I've reached the end of my mathematical knowledge. Similarly I don't know if moving one of the `n` exponentiations from the initial input to the secondary `zz` would improve the number of recursions or not (ditto reverse). # Lets go even slower with even more recursion ``` import math a=lambda x,y:(y<0)x or a(a(a(math.log(x+1),y-1),y-1),y-1) print a(input(),999e9)//1 ``` `n//1` - saves 2 bytes over `int(n)` * `import math`,`math.` saves 1 byte over `from math import` `a(...)` saves 8 bytes total over `m(m,...)` * `(y>0)x` [saves a byte](https://codegolf.stackexchange.com/questions/54/tips-for-golfing-in-python/103309#103309) over `y>0and x` ~~`9999` increases byte count by 4 and increases recursion depth by approximately [`2.8 * 10^x`](http://www.wolframalpha.com/input/?i=9%5E9%5E99) where `x` is the old depth (or a depth nearing a googolplex in size: 101094).~~ * `999e9` increases the byte count by 5 and increases recursion depth by...an insane amount. Recursion depth is now 1010109.93, for reference, a googolplex is 1010102. * lambda declaration increases recursion by an extra step: `m(m(...))` to `a(a(a(...)))` costs 7 bytes New output value (at 9 recursion depth): ``` >>>1.7976931348623157e+308 6.77538853089e-05 ``` Recursion depth has exploded to the point at which this result is literally meaningless except in comparison to the earlier results using the same input values: * The original called `log` 25 times * The first improvement calls it 81 times + The actual program would call it 1e992 or about 10102.3 times * This version calls it 729 times + The actual program would call it (9999)3 or slightly less than 101095 times). # Lambda Inception, score: ??? I heard you like lambdas, so... ``` from math import* a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1) print int(a(a,input(),1e99)) ``` I can't even run this, I stack overflow even with a mere 99 layers of recursion. The old method (below) returns (skipping the conversion to an integer): ``` >>>1.7976931348623157e+308 0.0909072713593 ``` The new method returns, using only 9 layers of incursion (rather than the full googol of them): ``` >>>1.7976931348623157e+308 0.00196323936205 ``` I think this works out to be of similar complexity to the Ackerman sequence, only small instead of big. Also thanks to ETHproductions for a 3-byte savings in spaces I didn't realize could be removed. Old answer: # The integer truncation of the function log(i+1) iterated ~~20~~ 25 times (Python) using lambda'd lambdas. PyRulez's answer can be compressed by introducing a second lambda and stacking it: ``` from math import * x=lambda i:log(i+1) y=lambda i:x(x(x(x(x(i))))) print int(y(y(y(y(y(input())))))) ``` ~~99~~ 100 characters used. This produces an iteration of ~~20~~ 25, over the original 12. Additionally it saves 2 characters by using `int()` instead of `floor()` which allowed for an additional `x()` stack. ~~If the spaces after the lambda can be removed (I cannot check at the moment) then a 5th `y()` can be added.~~ Possible! If there's a way to skip the `from math` import by using a fully qualified name (eg. `x=lambda i: math.log(i+1))`), that would save even more characters and allow for another stack of `x()` but I don't know if Python supports such things (I suspect not). Done! This is essentially the same trick used in [XCKD's blog post on large numbers](https://blog.xkcd.com/2007/03/14/large-numbers/), however the overhead in declaring lambdas precludes a third stack: ``` from math import * x=lambda i:log(i+1) y=lambda i:x(x(x(i))) z=lambda i:y(y(y(i))) print int(z(z(z(input())))) ``` This is the smallest recursion possible with 3 lambdas that exceeds the computed stack height of 2 lambdas (reducing any lambda to two calls drops the stack height to 18, below that of the 2-lambda version), but unfortunately requires 110 characters. [Answer] # [MATL](https://github.com/lmendo/MATL), 42 bytes ``` iXI:`2.]X{oXH1H/16L+XKxI:`Yl.]K+XKXdXzXGx ``` [Try it online!](https://tio.run/##y00syfn/PzPC0yrBSEsvNqI6P8LD0EPf0MxHO8K7AigamaMX6w1kR6REVEW4V/z/b2gAAA "MATL – Try It Online") This program is based on the harmonic series with the use of Euler–Mascheroni constant. As I was reading @LuisMendo documentation on his MATL language (with capital letters, so it looks important) I noticed this constant. The slow growth function expression is as following: [![enter image description here](https://i.stack.imgur.com/hUCD4.png)](https://i.stack.imgur.com/hUCD4.png) where εk ~ 1/2k* I tested up to 10000 iterations (in Matlab, since it is too large for TIO) and it scores below 10, so it is very slow. [![enter image description here](https://i.stack.imgur.com/59jvA.png)](https://i.stack.imgur.com/59jvA.png) Explanations: ``` iXI % ask user input (number of iterations) :`2.] % do...while loop, multiply by 2 X{ % convert numeric array into cell array o % convert to double precision array XH1H/ % copy to clipboard H and divide by 1: now we have an array of 1/2k 16L % Euler–Mascheroni constant + % addition (element-wise, singleton expansion) XKxI:` % save, clear the stack, do...while loop again Yl % logarithm .] % break, ends the loop K+XK % paste from clipboard K, sum all Xd % trim: keep the diagonal of the matrix Xz % remove all zeros XG % plot (yes it plots on-line too!) x % clear the stack % (implicit) display ``` Empirical proof: (ln k) + 1 in red always above lnk* + γ + εk in blue. [![enter image description here](https://i.stack.imgur.com/XeNJp.png)](https://i.stack.imgur.com/XeNJp.png) The program for (ln k) + 1 was made in ## Matlab, ~~47~~ ~~18~~ 14 bytes ``` n=input('') A=(1:n) for k=1:n A(k)=log(k)+1 end ``` Interesting to note that the elapsed time for n=100 is 0.208693s on my laptop, but only 0.121945s with `d=rand(1,n);A=d0;` and even less, 0.112147s with `A=zeros(1,n)`. If zeros is a waste of space, it saves speed! But I am diverging from the topic (probably very slowly). Edit: thanks to Stewie for ~~helping~~ reducing this Matlab expression to, simply: ``` @(n)log(1:n)+1 ``` [Answer] # [Haskell](https://www.haskell.org/), 100 bytes ``` f 0 a b=a^b f c a b=foldr(f$c-1)a$[0..b]>>[a] i=length.show 0#x=i x y#x=i$(y-1)#x g=(f(f 9 9 9)9 9#) ``` [Try it online!](https://tio.run/##XYq9CsMgFIV3n@KCDjpUzNiA2TvlAUIK1zT@UGtKEqh5ehs79hwO3zccj9tzjrEUCwoQjMa7IRamn9slPlZu2XRpBLJBSWnGrhtwJEHHObndy80vH6Jo1gEyOSoZP847zcRpbrmFa604R0V5YUhte@u5IFX1ew1pZw4a9Z/yBQ "Haskell – Try It Online") This solution does not take the inverse of a quickly growing function instead it takes a rather slowly growing function, in this case `length.show`, and applies it a bunch of times. First we define a function `f`. `f` is a bastard version of Knuth's uparrow notation that grows slightly faster (slightly is a bit of an understatement, but the numbers we are dealing with are so large that in the grand scheme of things...). We define the base case of `f 0 a b` to be `a^b` or `a` to the power of `b`. We then define the general case to be `(f$c-1)` applied to `b+2` instances of `a`. If we were defining a Knuth uparrow notation like construct we would apply it to `b` instances of `a`, but `b+2` is actually golfier* and has the advantage of being faster growing. We then define the operator `#`. `a#b` is defined to be `length.show` applied to `b` `a` times. Every application of `length.show` is an approximately equal to log10, which is not a very swiftly growing function. We then go about defining our function `g` that takes and integer in and applies `length.show` to the integer a bunch of times. To be specific it applies `length.show` to the input `f(f 9 9 9)9 9`. Before we get into how large this is lets look at `f 9 9 9`. `f 9 9 9` is greater than `9↑↑↑↑↑↑↑↑↑9` (nine arrows), by a massive margin. I believe it is somewhere between `9↑↑↑↑↑↑↑↑↑9` (nine arrows) and `9↑↑↑↑↑↑↑↑↑↑9` (ten arrows). Now this is an unimaginably large number, far to big to be stored on any computer in existence (in binary notation). We then take that and put that as the first argument of our `f` that means our value is larger than `9↑↑↑↑↑↑...↑↑↑↑↑↑9` with `f 9 9 9` arrows in between. I'm not going describe this number because it is so large I don't think I would be able to do it justice. Each `length.show` is approximately equal to taking the log base 10 of the integer. This means that most numbers will return 1 when `f` is applied to them. The smallest number to return something other than 1 is `10↑↑(f(f 9 9 9)9 9)`, which returns 2. Lets think about that for a moment. As abominably large as that number we defined earlier is, the smallest number that returns 2 is 10 to its own power that many times. Thats 1 followed by `10↑(f(f 9 9 9)9 9)` zeros. For the general case of `n` the smallest input outputting any given n must be `(10↑(n-1))↑↑(f(f 9 9 9)9 9)`. Note that this program requires massive amounts of time and memory for even small n (more than there is in the universe many times over), if you want to test this I suggest replacing `f(f 9 9 9)9 9` with a much smaller number, try 1 or 2 if you want ever get any output other than 1. [Answer] # Binary Lambda Calculus, 237 bits (under 30 bytes) ``` -- compute periods of final row of Laver tables as in as in -- section 3.4 of https://arxiv.org/pdf/1810.00548.pdf let -- Let mx = 2^n - 1. We consider a dual version of the shelf, determined -- by a \|> mx = a-1 (mod 2^n), which satisfies -- 0 \|> b = b -- a \|> 0 = 0 -- a \|> mx = a-1 -- a \|> b = (a \|> b+1) \|> a-1 -- Note that the latter two equations iterate f_a = \x. x \|> (a-1). -- In fact, for a > 0, we implement a \|> b = f_a^{mx-b} (a-1) as f_a^{mxb} 0, -- exploiting the fact that a \|> mx = a-1 = 0 \|> a-1 = f_a 0 -- and (modulo 2^n) 1+mx-b = -b = -1 b = mxb 0 = \f\x. x; 1 = \x. x; 2 = \f\x. f (f x); succ = \n\f\x. f (n f x); pred = \n\f\x. n (\g\h. h (g f)) (\h. x) (\x. x); laver = \mx. -- swap argument order to simplify iterated laver let laver = \b\a. a (\_. mx (b (laver (pred a))) 0) b in laver; dblp1 = \n\f\x. n f (n f (f x)); -- map n to 2n+1 find0 = \mx\i.laver mx i mx (\_.find0 mx (succ i)) i; period = \n.let mx = pred (n 2) in find0 mx 1 in period ``` compiles down to the 237 bits ``` 010000010101000110100000000101010101000110100000000101100001011111110011110010111110111100111111111101100000101101011000010101111101111011100000011100101111101101010011100110000001110011101000100000000101011110000001100111011110001100010 ``` This function grows to infinity assuming large cardinal axiom I3, which I believe is what Peter Taylor was hinting at. It grows way slower than any sort of inverse Ackerman. [Answer] # [Python 3](https://docs.python.org/3/), 100 bytes The floor of the function log(i+1) iterated 99999999999999999999999999999999999 times. One can use exponents to make the above number even larger... ``` from math import * s=input() exec("s=log(s+1);"99999999999999999999999999999999999) print(floor(s)) ``` [Try it online!](https://tio.run/##hcFBCoAgEADAu6@QTrt2ik4RPiZCU1BX1g3q9dsTmumvJGqramSqth6SbK6dWKwzw@fWbwE04QknTMMXumDMC@6T2/6h6ZybQCxEDANR9QM "Python 3 – Try It Online") [Answer] # APL, Apply `log(n + 1)`, `e^9^9...^9` times, where the length of the chain is `e^9^9...^9` of length of chain minus 1 times, and so on. ``` ⌊((⍟1+⊢)⍣((⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣(⍣⊢)))))))))))))))))))))9))⊢ ``` [Answer] ## The floor of the function log(i+1) iterated 14 times (Python) ``` import math x=lambda i: math.log(i+1) print int(x(x(x(x(x(x(x(x(x(x(x(x(x(x(input()))))))))))))))) ``` I don't expect this to do very well, but I figured its a good start. Examples: * e^n^n^n^n^n^n^n^n^n^n^n^n^n^n -> ~n (approximately n) [Answer] # Ruby, 100 bytes, score-1 = fωω+1(n2) Basically borrowed from my [Largest Number Printable](https://codegolf.stackexchange.com/a/120228), here's my program: ``` ->k{n=0;n+=1 until(H=->z,a=[0]z{b,c=a;z.times{z+=b ?H[z,b==1?c:[b>1?b-1:z]z+c]:z};z};H[nn]>k);n} ``` [Try it online](https://tio.run/##DcpLCsMgEADQq7hs/ZTYpTK69Q7iIiNZhLRDaRNIR3J2E3jL993w33foJiyNYPCkwIqN1vl1S2AC6xHyUCQ31LLC6Pmxzu/p11gBipgyawSwsbqMwUY01vG1VS2OD39JmSSVsNw9Hf0j9vws/QQ) Basically computes the inverse of fωω+1(n2) in the fast growing hierarchy. The first few values are ``` x[0] = 1 x[1] = 1 x[2] = 1 x[3] = 1 x[4] = 2 ``` And then it continues to output `2` for a very long time. Even `x[G] = 2`, where `G` is Graham's number. [Answer] ## Python, 100 bytes, \$999 \uparrow^{99999} \text{Score} = \text{Input}\$, using up-arrow notation ``` f=lambda b,i,n:n/b if i==0 else(0if n<=1else 1+f(b,i,f(b,i-1,n)));print(f(999,99999,int(input("")))) ``` This is based on extremely iterated logarithms, since most people know that logarithms alone grow pretty slowly. This program describes a ternary lambda function known simply as `f` which takes a base `b`, iterations `i` and input `n`. If `i == 0`, it just returns the input divided by the base. With `i == 1`, you may recognise the output as \$\text{max}(0, \lfloor \text{log}\_b(n)\rfloor)\$. Then, with `i == 2`, this is equal to \$\text{log\}(n) = \text{max}(0, \lfloor \text{slog}\_b(n)\rfloor)\$, where \$\text{slog}\$ is the super logarithm (iteration instead of exponentiation). Then, this program gets user input and returns \$\text{max}(0, \lfloor ^{99999}\text{log}\_{999}(n)\rfloor)\$. Here, \$^m\text{log}\$ is logarithm using \$\uparrow^m\$, so \$^2\text{log}\$ is \$\text{slog}\$. [Answer] ## Clojure, 91 bytes ``` (defn f (apply +(for[n(range %)](/(loop[r 1 v n](if(< v 1)r(recur( r v)(Math/log v)))))))) ``` Kind of calculates the `sum 1/(n * log(n) * log(log(n)) * ...)`, which I found from [here](https://math.stackexchange.com/a/452441). But the function ended up 101 bytes long so I had to drop the explicit number of iterations, and instead iterate as long as the number is greater than one. Example outputs for inputs of `10^i`: ``` 0 1 1 3.3851305685279143 2 3.9960532565317575 3 4.232195089969394 4 4.370995106860574 5 4.466762285601703 6 4.53872567524327 7 4.595525574477128 8 4.640390570825608 ``` I assume this modified series still diverges but do now know how to prove it. > > The third series actually requires a googolplex numbers of terms before the partial terms exceed 10. > > > [Answer] ## Mathematica, 99 bytes (assuming ± takes 1 byte) ``` 0±x_=1±(x-1);y_±0=y+1;x_±y_:=(y-1)±x±(x-1);(i=0;NestWhile[(++i;#±#±#±#±#±#±#±#)&,1,#<k&/.k->#];i)& ``` The first 3 commands define `x±y` to evaluate `Ackermann(y, x)`. The result of the function is the number of times `f(#)=#±#±#±#±#±#±#±#` need to be applied to 1 before the value get to the value of parameter. As `f(#)=#±#±#±#±#±#±#±#` (that is, `f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]`) grow very fast, the function grow very slow. [Answer] # Javascript (ES6), 94 bytes ``` (p=j=>i=>h=>g=>f=>x=>x<2?0:1+p(p(j))(j(i))(i(h))(h(g))(g(f))(f(x)))(_=x=>x)(_)(_)(_)(Math.log) ``` Explanation: `Id` refers to `x => x` in the following. Let's first take a look at: ``` p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x)) ``` `p(Math.log)` is approximately equal to `log(x)`. `p(p(Math.log))` is approximately equal to `log(x)` (number of times you can take `log` until the value is at most 1). `p(p(p(Math.log)))` is approximately equal to `log*(x)`. The inverse Ackermann function `alpha(x)` is approximately equal to the minimum number of times you need to compose `p` until the value is at most 1. If we then use: ``` p = g => f => x => x < 2 ? 0 : 1 + p(p(g))(g(f))(f(x)) ``` then we can write `alpha = p(Id)(Math.log)`. That's pretty boring, however, so let's increase the number of levels: ``` p = h => g => f => x => x < 2 ? 0 : 1 + p(p(h))(h(g))(g(f))(f(x)) ``` This is like how we constructed `alpha(x)`, except instead of doing `log...(x)`, we now do `alpha...(x)`. Why stop here though? ``` p = i => h => g => f => x => x < 2 ? 0 : 1 + p(p(i))(i(h))(h(g))(g(f))(f(x)) ``` If the previous function is `f(x)~alpha...(x)`, this one is now `~ f...**(x)`. We do one more level of this to get our final solution. ]

Subsets and Splits