# Puzzles/2147483647

## Problem

Provide a sentence whose result is 2147483647.

### Constraints

The following constraints are listed in order. That is, sentences which satisfy constraint N equally are selected from by constraint N+1. All sentences must satisfy constraints 0, 1, and 2.

1.#0 Sentence must produce 2147483647. That is, satisfy 2147483647&-:@:".. This constraint is absolute. 1. The result must be guaranteed (predicted, fully supported) by the Dictionary. To put it another way, you may not leverage bugs in the implementation (but you may leverage bugs in the documentation). This constraint is absolute. 1. Assume you're running under \$jconsole -jprofile: that is, you may not depend on any sentence having been executed before your own (but see the section "Note on display"). Put another way, do not rely on the names normally defined by the J standard library. This constraint is absolute. 1. Among sentences that satisfy the preceding constraints equally, those with the minimum number of characters composing nouns are preferred. That is, minimize +/@:(#&> * 0: = 3 : '4!:0 {.;:''u''[". ::0:''u=.'',y.'&>)@:;:. 1. Among sentences that satisfy the preceding constraints equally, those with the smallest number of words are preferred. That is, minimize #@:;:. 1. Among sentences that satisfy the preceding constraints equally, those the smallest number of total characters are preferred. That is, minimize #.

### Note on display

Note that, in the default J configuration, integer 2147483647 displays in full, but floating point 2147483647 does not. If your sentence produces a floating point result, you may have to increase your print precision to see this value.

To do so, use 9!:11]16. You may assume that sentence has been run prior to your solution sentence, and that it does not count as part of your sentence.

Alternatively, you may append a single trailing x to one numeric noun in your sentence, and that character will not count as part of your sentence; it will be treated as if it were not there. That is, it does not count towards the number of characters composing the noun, nor towards the total number of characters in the sentence, nor towards any other constraint.

### Guidelines

I do not wish to break the standing solutions. But in retrospect, the following would have been constraints. Consider them guidelines.

1. Sentences should convey something meaningful or unique about 2147483647. This could never have been a constraint, as it cannot be defined rigorously. But, as examples, the number is:
• The highest signed 32-bit IEEE integer: 2147483647 -: #. 0 , 31 # 1. 32-bit IEEE signed integers are a very common format as of this writing.
• Prime: 1 -: # q: 2147483647
• A Mersenne prime: 2147483647 -: <: 2 ^ p: 10.
• An iterated Mersenne prime: 2147483647 -: <: 2 ^ <: 2 ^ p: 2 or 2147483647 -: (2&(<:@:^) p:) 2.
2. The challenge could be tightened with "minimize repetitions of primitives; that is, minimize >./@:(#/.~)@:;:". Put another way, given an arbitrarily long string of J verbs and a single digit number, any integral value could be calculated. The simplest example is: +/(],],], ... )1 using the appropriate number of repetitions of ,]. Though such solutions would lose out to versions using fewer verbs, they still evade the spirit of the challenge. Don't submit them.
3. Perhaps the nouns themselves should be minimized. That is, where two solutions which satisfy the other constraints equally, but one mentions only 2 where the other mentions 5, the former is preferred. But much thought would have to be given forms such as __ and 'literal', etc.
4. Given the display issue, perhaps the datatype of the output could be considered. That is, where two solutions which satisfy the other constraints equally, but one outputs an integer and the other a float, then the former is preferred.

## Solutions

 No. Sentence Noun chars Words Total chars Notes Author/Sig 0 2<:@^^:[5 2 7 10 Solution is one character less than 2147483647 itself. -- Dan Bron <> 1 <:(*-:)*:*:+:8 1 9 14 -- Roger Hui <> 2 <:(*-:)*:*:*:*:#+`+ 0 13 19 -- Roger Hui <> 3 <:-:*:*:*:*:*:#+`+ 0 11 18 -- Roger Hui <> 4 <:-:*:*:^~*:#+`+ 0 11 16 -- Ewart Shaw <> 5 #.=~i.<:+:*:4:+`+ 0 11 17 -- Roger Hui <> 6 #.*i.+:*:4:+`+ 0 9 14 -- Ewart Shaw <> 7 (<:@^~#)~^:]~#`5: 0 14 17 Worse than the others. But the idea is there... -- Dan Bron <> 8 p:\$:@>:&.p: ::]#+`+ 0 12 18 very inefficient (be prepared to use jbreak or kill your j session), and depends on p: implementation limit -- only theoretically correct even with those constraints, probably dies with a stack error -- Raul Miller <> 9 (<:@^^:[p:)#+`+ 0 12 15 Still not as good. -- Dan Bron <> 10 #.@:*@\$~^:2:#{.":?`? 0 14 20 Not very good. -- B Jonas <> 11 #.@:*@\$~^:2:5:?`? 0 12 17 A demoronized version of the previous one -- B Jonas <> 12 <:-:(#^#^5:)?`? 0 12 15 A saner 12er -- B Jonas <> 13 #.@:*@\$~^:]2:`5: 0 11 16 Nice idea, Dan Bron -- B Jonas <> 14 ".}.}.;?`o2147483647 0 7 20 Whoopsie, sorry -- B Jonas <> 15 ".}.;o2147483647`j0 0 6 19 Even -- B Jonas <> 16 .;x7463847412`] 0 6 18 -- B Jonas <> 17 33 b.~_1 4 4 8 Merely interesting; drawbacks are that it has many noun-characters and is machine-architecture-dependent -- Dan Bron <> 18 ->:{.i:_j1 4 4 8 Same note as no. 17: solution is merely interesting; drawbacks are that it has many noun-characters and is machine-architecture-dependent -- Dan Bron <>