Any digital permutation

Question

Task

Your task is to output a single integer, with one restriction: its digits must be a permutation of [1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6].

For example, you could output 653443653152432, 413265345463352, or any of the other 15-digit integers whose digits are a permutation of the list.

Rules

• Your code must terminate in a reasonable amount of time (do not just enumerate every integer until you get to 122333344455566).

• If your language doesn't support 15-digit integers, or if there is no meaningful distinction between strings and integers in your language, you may output a string.

• This is code-golf, shortest answer in bytes wins.

Answer 1

JavaScript (ES7), 13 12 bytes

let f =

_=>266**6+19

console.log(f())

This computes: 266⁶ + 19 = 354233654641216 + 19 = 354233654641235

There are two triples (a, b, c) with 0 < a < 1000, 0 < b < 10, 0 < c < 100 and a^b + c satisfying the condition.

The following snippet finds them almost instantly.

for(a = 1; a < 1000; a++) {
  for(b = 1; b < 10; b++) {
    for(c = 1; c < 100; c++) {
      if((r = a**b + c + '').match(/^[1-6]+$/) && [...r].sort().join`` == '122333344455566') {
        console.log(a + '**' + b + ' + ' + c + ' = ' + r);
      }
    }
  }
}

Answer 2

Brain-Flak, 65 bytes

(((((((((((((((((((()()()){}){}){}){}())()))()))))())))())))()))

Try it online!

This is 64 bytes of source code and +1 for the -A flag. This simply pushes the ASCII values of each digit in a row. For reference, pushing the number 122333344455566 would take 238 bytes:

(((((((((((((((((((((((((((((((((((((((((((((((((()()()){}){}){})()){}{}){({}[()])}{}){}){}())){}{})){}{}){}())){}{})()){}{})){}{}){}())){}{}){}())){}{}){}())()){}{})()){}{})){}{})()){}{})()){}{})){}{}){}())){}{}){}())){}{})){}{}){}()){})

Try it online!

Answer 3

V, 12, 10 bytes

2¬26¬35a13

Try it online!

This generates the range [2, 6] twice, then the range [3, 5], and then appends 13.

Outputs:

234562345634513

Answer 4

Turing machine, 132 122 bytes

...and 11 10 8 7 states, including halt.

0 _ x r A
0 x y r A
0 y z r A
0 z _ r C
0 * * l 0
A _ 6 r B
A * * r A
B _ 2 r C
C * 3 r D
D _ 4 r E
D 2 1 l halt
E _ 5 l 0

Here is a Turing machine simulator that understands this syntax. You should paste the code, clear the "Initial input" field, press Reset, then press Run.

How it works

Outputs 313456234562345 by looping to write 62345 three times and then writing 31 on top of the initial 62.

---

-10 bytes thanks to @Leo

Answer 5

Jelly, 9 8 bytes

“|BS½GA’

Try it online!

Simply a base-250 compressed version of the number 122333344455566

Saved 1 byte thanks to @Mr. Xcoder

Answer 6

SOGL V0.12, 7 bytes

↓čvν□⅟“

Try it Here!
A simple compressed number.

Alternate 9 byte run-length version:

Ƨ≡+‰“7─◄H

Try it Here!

Answer 7

brainfuck, 40 bytes

+++++++[>+++++++<-]>.+..+....+...+...+..

Try it online!

fairly boring solution

Answer 8

05AB1E, 7 bytes

•=["∊…Q

Try it online!

Answer 9

Befunge-93, 16 14 or 12 bytes

The only native integer literals supported by Befunge are the numbers 0 to 9, so coming up with an efficient representation for larger values is actually quite a common problem. In this case, though, it's not just a matter of finding the most efficient representation for a number, but also choosing a target number whose best representation is the shortest of all possible targets.

After trying thousands of different combinations, the best I've been able to do so far is 14 bytes (12 to calculate the number, and then two more bytes to output it).

m&"7*:*::**+.@

Try it online!

If we allow extended ASCII characters, though, we can improve on the above solution by two bytes with:

eûãÃ"**:*+.@

This is using the Latin-1 encoding, which we unfortunately can't demonstrate on TIO, since it doesn't support 8-byte encodings for the Befunge interpreters.

Explanation

In the first answer, we start with the string "m&", which essentially pushes the values 109 and 38 onto the stack. Note that we save a byte by dropping the opening quote, since we can rely on Befunge's wrap-around playfield to have the one quote both open and close the string (this pushes a number of additional values onto the stack that we don't need, but we only care about the final two).

We then push an additional 7 onto the stack, and execute the sequence *:*::**+, which performs a set of arithmetic calculations with the stack values, essentially calculating the expression:

109+(38*7)^2^3 = 354233654641325

Finally we use the . instruction to output the result of the calculation, and then the @ instruction ends the program.

In the second answer, we start with the string "eûãÃ", which pushes the values 101, 251, 227 and 195. We then execute the sequence **:*+, which performs the required calculations on those values:

101+(251*227*195)^2 = 123443543565326

And again we finish with the instructions . and @ to output the result and exit.

Note that in both cases you need to be using an interpreter which supports 64-bit integers. Also note that the string wrapping trick won't work on Befunge-98 interpreters, since it relies on the interpreter ignoring instructions it doesn't recognise, but in Befunge-98 an invalid instruction will reflect.

Answer 10

Vyxal, 7 bytes

»Ċ¨?»²›

Try it Online!

Port of the second answer here
Explanation:

»Ċ¨?»   # Compressed integer 11972312
     ²  # Squared
      › # Increment

I was on my way to making a super short one but I had read the rules wrong :(

Answer 11

Python 2, 21 bytes

print 122333344455566

Try it online!

Answer 12

Jelly, 12 bytes

4967b5Ėẋ/€FḌ

Try it online!

could probably be shorter

Answer 13

Pyth, 9 bytes

."16U<³

Try it here!

Output:

223133344455566

Answer 14

Tcl, 89 bytes

proc f a\ b {expr rand()>.5}
puts [join [lsort -command f [split 122333344455566 ""]] ""]

Try it online!

Answer 15

Tcl, 20 bytes

puts 122333344455566

Try it online!

Answer 16

Befunge-98 (FBBI), 20 bytes

"ek,@122333344455566

Try it online!

Output is 665554443333221.

Answer 17

Groovy, 23 bytes

{"233456"​​​​​*2+145​}​

Outputs: 233456233456145

Answer 18

APL (Dyalog Unicode), 14 bytes

⎕pp←30
37+266*6

Try it online!

Used @Arnauld's snippet, so credit goes to them.

Answer 19

C++, 24 bytes

[]{return(57LL<<41)-31;}

Try it online!

Returns 57×2⁴¹−31 = 125344325566433.

Answer 20

ARM T32 machine code, 8 bytes

20d5 f24e 6157 4770

Following the AAPCS, this is a function returning a 64-bit integer in r0 and r1. The number is 58967×2³²+213=253261336543445.

Disassembled:

20d5        movs    r0, #213
f24e 6157   movw    r1, #58967
4770        bx  lr

Answer 21

A0A0, 16 bytes

O122333344455566

O outputs the number after it. The number after it is a valid integer.

I don't really think it's possible to save bytes by using some arithmetic expression. When multiplying two numbers of n and m digits, the resulting length of the multiplication will be at most n + m. Doing such a multiplication requires at least n + m + 2 (ignoring the operand) bytes, at which point you might as well just write the result directly. Addition is even worse in terms of length. Considering multiplication, addition and subtraction are the only built-in operators I find it hard to believe this can be shortened. I'd love to be proven wrong, though.

Answer 22

x86 32-bit machine code, 9 bytes

6A 85 58 BA 4F C9 00 00 C3

Returns a 64-bit integer in EDX and EAX, as is standard. The value is 51536×2³²−123 = 221345434566533.

Try it online!

In assembly:

f:  push -123; pop eax
    mov edx, 51535
    ret

---

Some alternatives that also take 9 bytes:

---

B8 D8 AE B6 00 F7 E0 40 C3

Try it online!

f:  mov eax, 11972312
    mul eax
    inc eax
    ret

11972312²+1 = 143336254625343

---

6A E1 58 0F B6 D4 B6 71 C3

Try it online!

f:  push -31; pop eax
    movzx edx, ah
    mov dh, 113
    ret

114×2⁴⁰−31 = 125344325566433