Skip to main content

Featured Post

Your First Programming Language

What programming language you start with really all depends on where you want to go with programming/coding. The great thing about this field is that there are an absolute abundance of smaller fields that you can go into, all using programming in their own unique ways. For web applications, a good start would be with HTML and later moving your way through CSS, JavaScript, JQuery, PHP, SQL, and any of the JavaScript libraries. Ruby is also a popular choice, so I would recommend checking that out too. For more scientific fields or areas with more machine learning and A.I., Python is generally a great place to start as it is widely used in that field of study. C++ is also a very useful language to know for that, but it can be a little more challenging for beginners. For game and application design, languages such as C#, C, Swift, Kotlin, and Java are most often used for that.

Integer Complexity 3

Background
The integer complexity of a positive integer is the minimum possible sum of the numbers used in an expression - using only positive integers, addition, multiplication, and parentheses - that's equal to the given number. See this week's Intermediate challenge for examples and more information.

The typical definition of integer complexity disallows all numbers in the expression other than 1. This definition is equivalent, so either one you want to use is fine.

As far as I know, efficiently determining the integer complexity of a given number is an open question. Your challenge is to provide as tight an upper limit as possible for a particular input.

Challenge
Post an expression equal to 12345678910111213 - using only positive integers, addition, multiplication, and parentheses - such that the sum of the numbers in the expression is as small as possible.

Here's one example:

1+4*3*3*3*(1+4*4*(1+3*(1+3*(1+5*3*3*(1+5*4*4*2*(1+4*3*(1+4*4*3*2*(2+5*(1+5*4*3*(1+3*(1+5*3*(2+5*1))))))))))))
If you add up all the numbers in this expression (1+4+3+3+3+...+2+5+1) you get a sum of 122. How much better can you do? When this post is 7 days old, the expression with the smallest sum will merit +1 gold medal flair.

Challenge details
Don't worry about formatting it neatly. Output format doesn't matter as long as you can explain how to make sense of it.

In the event of a tie, also post an expression for 1234567891011121314, 123456789101112131415, etc. I'll break ties by looking at the first sum where your solutions differ.

If you post your solution to this thread, it's fair game for others to work off. You may PM me your solution instead of posting if you don't want people to use them for their own solutions, but it would be great if you also post the sum here so people have a goal to work for. I will verify anybody's claim, so for instance you can comment, "I found an expression with a sum of 118" and PM me the expression, and then I'll reply to your comment saying that I have confirmed that your expression is valid. After 10 days I'll post anybody's solution who PM'd me but didn't post it, so everything will eventually be public.

I reserve discretion to give the award to whoever made the largest contribution to the best solution, if my criterion would technically give it to someone else. But if you feel this is unfair, let me know and we'll work it out.

Solution
in Java

12345678910111213: 114
Full solution:
1 + (3 * 2) * ((3 * 2) * 3) * (1 + (4 * 4) * (1 + ((4 * 3 + 1) * 3) * (1 + (3 * 2) * ((4 * 2) * (3 * 2 + 1) + 1) * (1 + ((5 * 2) * (4 * 2)) * ((4 * 3) * (3 * 2 + 1) + 2) * ((4 * 3) * (4 * 2)) * (1 + (3 * 3) * ((5 * 2) * (3 * 3)))))))

1234567891011121314: 127
Full solution:
(3 * 2) * (1 + (3 * 2) * (3 * 3) * (1 + ((3 * 3) * (3 * 2)) * (1 + ((4 * 2) * 4) * (1 + ((4 * 2) * 4) * (1 + ((4 * 2) * (4 * 2)) * (1 + ((3 * 2) * (3 * 2)) * (1 + ((3 * 2) * 4) * ((3 * 3) * (3 * 3)) * (1 + ((3 * 2) * 4) * (1 + (4 * 2) * ((5 * 2) * (4 * 2)))))))))))

123456789101112131415: 142
Full solution:
(5 * 3) * (1 + ((4 * 2) * 5) * (1 + ((3 * 3) * (3 * 2)) * (1 + ((3 * 3) * (3 * 2)) * (1 + ((4 * 2) * 4) * (1 + ((4 * 2) * 4) * (1 + ((4 * 2) * (4 * 2)) * (1 + ((3 * 2) * (3 * 2)) * (1 + ((5 * 2) * (3 * 3)) * ((4 * 4 + 1) * 4) * ((3 * 3) * 3) * (1 + ((5 * 2) * (3 * 3)) * 2)))))))))

12345678910111213141516: 158
Full solution:
(1 + ((4 * 3) * (3 * 2 + 1) + 1) * (3 * 3) * (1 + ((5 * 2) * (3 * 3)) * (1 + ((5 * 2 + 1) * (3 * 2)) * (1 + ((5 * 2 + 1) * (3 * 3)) * (((3 * 2) * 3 + 1) * 2) * (1 + ((4 * 3) * (3 * 2 + 1) + 2) * (4 * 4 + 1) * (3 * 3) * (1 + ((4 * 3) * (4 * 2)) * ((3 * 3) * (3 * 2 + 1)) * ((3 * 3) * (3 * 2) + 1) * ((3 * 3) * (3 * 2) + 1) * 3))))))

1234567891011121314151617: 170
Clean solution: 0 + 14979 * (0 + 141 * (1 + 6 * (1 + 72 * (1 + 6921 * (0 + 6 * (1 + 3312 * (1 + 192 * (1 + 5124 * (0 + 10)))))))))
Full solution: ((((4 * 3 + 1) * (3 * 2)) * ((4 * 2) * (4 * 2)) + 1) * 3) * (((3 * 2 + 1) * 2) * (5 * 2) + 1) * (1 + (3 * 2) * (1 + ((3 * 3) * (4 * 2)) * (1 + (((4 * 4 + 1) * (5 * 2 + 1)) * ((3 * 2) * (3 * 2) + 1) + 2) * (3 * 2) * (1 + (((5 * 4 + 3) * (3 * 2)) * ((3 * 2) * 4)) * (1 + ((4 * 4) * (4 * 3)) * (1 + (((4 * 3) * (3 * 2 + 1)) * ((5 * 2) * (3 * 2) + 1)) * (5 * 2)))))))

Comments

Popular posts from this blog

Decipher A Seven Segment Display

Description Today's challenge will be to create a program to decipher a seven segment display, commonly seen on many older electronic devices. Input Description For this challenge, you will receive 3 lines of input, with each line being 27 characters long (representing 9 total numbers), with the digits spread across the 3 lines. Your job is to return the represented digits. You don't need to account for odd spacing or missing segments. Output Description Your program should print the numbers contained in the display. Challenge Inputs     _  _     _  _  _  _  _   | _| _||_||_ |_   ||_||_|   ||_  _|  | _||_|  ||_| _|     _  _  _  _  _  _  _  _ |_| _| _||_|| ||_ |_| _||_   | _| _||_||_| _||_||_  _|  _  _  _  _  _  _  _  _  _ |_  _||_ |_| _|  ||_ | ||_|  _||_ |_||_| _|  ||_||_||_|  _  _        _  _  _  _  _ |_||_ |_|  || ||_ |_ |_| _|  _| _|  |  ||_| _| _| _||_ Challenge Outputs 123456789 433805825 526837608 954105592 Solution in Go package mai

Continued Fraction

Description In mathematics, a continued fraction is an expression obtained through an iterative process of representing a number as the sum of its integer part and the reciprocal of another number, then writing this other number as the sum of its integer part and another reciprocal, and so on. A continued fraction is an expression of the form             1     x + ----------                1         y + -------                   1             z + ----                  ... and so forth, where x, y, z, and such are real numbers, rational numbers, or complex numbers. Using Gauss notation, this may be abbreviated as [x; y, z, ...] To convert a continued fraction to an ordinary fraction, we just simplify from the right side, which may be an improper fraction, one where the numerator is larger than the denominator. Continued fractions can be decomposed as well, which breaks it down from an improper fraction to its Gauss notation. For example: 16        1 -- = 0 + --- 45

Kolakoski Sequence

Description A Kolakoski sequence (A000002) is an infinite sequence of symbols {1, 2} that is its own run-length encoding. It alternates between "runs" of symbols. The sequence begins: 12211212212211211221211212211... The first three symbols of the sequence are 122, which are the output of the first two iterations. After this, on the i-th iteration read the value x[i] of the output (one-indexed). If i is odd, output x[i] copies of the number 1. If i is even, output x[i] copies of the number 2. There is an unproven conjecture that the density of 1s in the sequence is 1/2 (50%). In today's challenge we'll be searching for numerical evidence of this by tallying the ratio of 1s and 2s for some initial N symbols of the sequence. Input Description As input you will receive the number of outputs to generate and tally. Output Description As output, print the ratio of 1s to 2s in the first n symbols. Sample Input 10 100 1000 Sample Output 5:5 49:51 502:498

Advanced pacman

Description This challenge takes its roots from the world-famous game Pacman. To finish the game, pacman needs to gather all pacgum on the map. The goal of this chalenge is to have a time-limited pacman. Pacman must gather as much pacgum as possible in the given time. To simplify, we will say that 1 move (no diagonals) = 1 unit of time. Formal Inputs & Outputs Input description You will be given a number, the time pacman has to gather as much pacgum as possible, and a table, being the map pacman has to explore. Every square of this map can be one of those things : A number N between (1 and 9) of pacgums that pacman can gather in one unit of time. "X" squares cannot be gone through. "C" will be where pacman starts. "O" (the letter, not zero ) will be a warp to another "O". There can be only 2 "O" on one map; Output description Your program should output the maximum number of pacgums pacman can gather in the given t

Puzzle Me This

Description First they took our jerbs, now they're taking our puzzles! (with your help) Today we're gonna find a way to solve jigsaw puzzles using computers Input Description As I am no designer the input will be purely numerical, feel free to make some visual version of the jigsaw puzzles :) You will first be given the dimension as X, Y Afterwards you will be given list of puzzle pieces and what type their 4 sides connect to (given as up, right, down, left) Their side-connection is given as a number, They connect with their negated number this means that a 1 and -1 connects, 2 and -2 connects etc. 0 means that it doesnt connect with anything. Assume pieces are rotated in the correct direction. fx: 2, 2 0: 0,1,2,0 1: 0,0,2,-1 2: -2,0,0,2 3: -2,-2,0,0 Output Description Output is a 2D picture/matrix of the pieces in their correct position for the example this would be 0 1 3 2 Challenge Input Challenges are generated, so there is a slight chanc

Everyone's A Winner

Description Today's challenge comes from the website fivethirtyeight.com, which runs a weekly Riddler column. Today's dailyprogrammer challenge was the riddler on 2018-04-06. From Matt Gold, a chance, perhaps, to redeem your busted bracket: On Monday, Villanova won the NCAA men’s basketball national title. But I recently overheard some boisterous Butler fans calling themselves the “transitive national champions,” because Butler beat Villanova earlier in the season. Of course, other teams also beat Butler during the season and their fans could therefore make exactly the same claim. How many transitive national champions were there this season? Or, maybe more descriptively, how many teams weren’t transitive national champions? (All of this season’s college basketball results are here. To get you started, Villanova lost to Butler, St. John’s, Providence and Creighton this season, all of whom can claim a transitive title. But remember, teams beat those teams, too.) Outp

Star Battle solver

Background Star Battle is a grid-based logic puzzle. You are given a SxS square grid divided into S connected regions, and a number N. You must find the unique way to place N*S stars into the grid such that: Every row has exactly N stars. Every column has exactly N stars. Every region has exactly N stars. No two stars are horizontally, vertically, or diagonally adjacent. If you would like more information: Star Battle rules and info YouTube tutorial and written tutorial of solving Star Battle puzzles by hand There are many Star Battle puzzles available on Grandmaster Puzzles. Just be aware that some are variants that follow different rules. Challenge Write a program to solve a Star Battle puzzle in a reasonable amount of time. There's no strict time requirement, but you should run your program through to completion for at least one (N, S) = (2, 10) puzzle for it to count as a solution. Feel free to use whatever input/output format is most convenient for you. In the