# Question
Title: Determine if a number is divisible by 13 (without using 13 itself)
Your challenge, should you choose to accept it, is to create a function or a program that outputs "yes" if a given number is divisible by 13 and outputs "no" if it isn't.

**Rules:**
\- You're not allowed to use the number 13 anywhere.
\- No cop-out synonyms for 13 either (like using 15 - 2).
\- Bonus points will be awarded for not using modulus, additional bonus for not using division.

**Scoring:**
\- Your score will be the number of bytes in your code (whitespace *not* included) multiplied by your bonus.
\- If you didn't use modulus, that bonus is 0.90; if you didn't use division, that bonus is 0.90.
\- If you didn't use either, that bonus is 0.80.
\- The lower your score, the better.

The input will always be an integer greater than 0 and less than 2^32.
Your output should be a simple "yes" or "no".

**Clarifications:**
\- Using some roundabout method of generating the number 13 for use is acceptable. Simple arithmetic synonyms like (10 + 3) are not allowed.
\- The function or program must *literally output* "yes" or "no" for if the given number is divisible by 13.
\- As always, clever solutions are recommended, but not required.

# Answer
> 23 votes
## Java (score 60.8 59.2)

```
void t(int n){System.out.print(Math.cos(.483321946706122*n)>.9?"yes":"no");}

```

Score: (76 - 2 whitespace) chars * 0.8 = 59.2

# Answer
> 19 votes
**ASM - 16 bit x86 on WinXP command shell**

executable - 55 bytes * 0.8 = 44

source - 288 characters * 0.8 = 230.4

The number 13 doesn't even appear in the assembled .com file.

Assemble using A86.

```
    mov si,82h
    xor ax,ax
    xor cx,cx
a:  imul cx,10
    add cx,ax
    lodsb
    sub al,48
    jnc a
    inc cx
h:  mov dl,a and 255
c:  loop g
    sub dl,a and 255
    jz e
    mov dl,4
e:  add dl,k and 255
    mov dh,1
    mov ah,9
    int 21h
    ret
g:  inc dl
    cmp dl,c and 255
    jne c
    jmp h
k:  db 'yes$no$'

```

# Answer
> 18 votes
# Python 3.x: 54 * 0.8 = 43.2

It may be a cop-out to have a string of length 13, but here it goes:

```
print('no' if any((' ' * int(input())).split('             ')) else 'yes')

```

It works by building a string of n spaces (the choice of delimiter is arbitrary, but I chose space for obvious reasons), and splitting away 13-space substrings until you're left with a string containing n%13 spaces.

# Answer
> 14 votes
## GolfScript, 32 chars

```
~){.14base{+}*.@<}do('no''yes'if

```

I wanted to try something different from everyone else, so my solution calculates the base 14 digital root of the number, by repeatedly converting the number to base **14** and summing the digits until the result no longer gets any smaller. This is essentially the same as calculating the remainder modulo 13, except that the result will be in the range 1 to 13 instead of 0 to 12.

Since checking whether the digital root equals 13 would be difficult without using the number 13 itself (or some lame workaround like 12+1), what I actually do is I increment the input number by one before the loop and decrement the result afterwards. That way, the result for numbers divisible by 13 will in fact be zero, which is much easier to check for.

Here's a commented version of the program:

```
~              # evaluate the input, turning it from a string to a number
)              # increment by one
{              # start of do-loop
    .          # make a copy of the previous number, so we can tell when we're done
    14 base    # convert the number to base 14
    { + } *    # sum the digits
    . @ <      # check if the new number is less than the previous number...
} do           # ...and repeat the loop if so
(              # decrement the result by one
'no' 'yes' if  # output 'no' if the result is non-zero, 'yes' if it's zero

```

This program will actually handle *any* non-negative integer inputs, since GolfScript uses bignum arithmetic. Of course, extremely large inputs may consume excessive time and/or memory.

The code does not use either modulos or division directly, although it does use GolfScipt's base conversion operator, which almost certainly does some division and remainder-taking internally. I'll leave it for GigaWatt to decide whether this qualifies me for the bonus or not.

# Answer
> 12 votes
## C, 68 * 0.8 = 54.4

After 24 answers, no one came up with this obvious algorithm yet:

```
f(x){puts("no\0yes"+3*((x*330382100LL>>32)-(~-x*330382100LL>>32)));}

```

# Answer
> 11 votes
## JavaScript (27.9)

Current version (31 characters * 0.90 bonus = 27.9).

```
alert(prompt()*2%26?'no':'yes')

```

Demo: http://jsfiddle.net/9GQ9m/2/

**Edit 1:** Forgo second bonus by using modulus to lower score considerably and avoid `for` loop. Also eliminate `~~` and save two chars (thanks `@copy`).

---

Older version (48 characters * 0.80 bonus = 38.4)

```
for(n=~~prompt()*2;n-=26>0;);alert(n?'no':'yes')

```

# Answer
> 7 votes
## BrainFuck

Score: 200 * 0.8 = 160

```
>++++++[>++++++++<-]>>,[<[-<+>>-<]<[->+<]>>>[->++++++++++<]>[-<+>]<<[->+<],]++++
+++++++++>[>+<-<-[>>>]>>[[-<<+>>]>>>]<<<<]>[<<<[-<++>]<++++++++++++++.+.>]<<[[-<
++++++<++++++++>>]<-----.<---.>------.>]

```

Reads froms stdin. Probably not the most clever solution, but getting anything that works in BF is nice. It's quite compact though.

# Answer
> 7 votes
**Scala (38 * 0.9 = 34.2)**

Similar to `0xD`(hex) or `015`(oct).

**ASCII** value of `CR` is 13.

```
def t(n:Int)=if(n%'\r'==0)"yes"else"no"

```

# Answer
> 5 votes
## Haskell, 28 * 0.8 = 22.4

```
f x|gcd 26x>2="yes"|1<3="no"

```

# Answer
> 5 votes
Python:

```
f=lambda n:1==pow(8,n,79)

```

E.g.

```
[i for i in range(100) if f(i)]

```

gives

```
[0, 13, 26, 39, 52, 65, 78, 91]

```

# Answer
> 4 votes
### ECMAScript 6, 25 × 0.9 = 22.5

Yeah, it's a boring way of getting 13.

```
n => n % '             '.length ? 'no' : 'yes'

```

# Answer
> 4 votes
## C, 54.4 == 68 * .8 80 * .8

```
char*f(c){char*s=" yes\0\rno";while(c&&*s++);return c>0?f(c-*s):++s;}

```

# Answer
> 3 votes
## APL ((21 - 1) × 0.8 = 16)

```
'yes' 'no'[1=⎕∨⌊⍟9*6]

```

`⎕IO` should be set to 0 for this to work properly in Dyalog APL. To generate 13, we take the floor () of the natural logarithm () of 9 to the power of 6 (`9*6`). After that, we find the GCD () of our input () and 13, and we then test if that equals 1. This is used to index (`[...]`) the vector of answers.

If anyone wants to be pedantic about the mention of *bytes* in the scoring specification, the score for the UTF-8 encoded version of this is `(29 - 1) × 0.8 = 22.4`. :)

# Answer
> 3 votes
## C, 88

Fibonacci trick.

```
f(n){return n<2?n:f(n-1)+f(n-2);}main(x){printf("%s",x%f(7)?"No":"Yes",scanf("%d",&x));}

```

# Answer
> 3 votes
## Perl - 44 × 0.8 = 35.2

```
#!perl -p
map$_+=4*chop,($_)x10;$_=chop^$_*3?'no':yes

```

Counting the shebang as one byte.

I'm a bit late to the game, but I thought I'd share the algorithm, as no other posts to this point have used it.

This works under the observation that if *n* is divisible by *13*, then ⌊*n/10*⌋+*n%10\*4* is also divisible by *13*. The values *13*, *26* and *39* cycle onto themselves. All other multiples of *13* will eventually reach one of these values in no more than *log10 n* iterations.

---

**In Other Bases**

Admittedly, `chop` is a bit of a cop-out. With a base 10 representation, it's equivalent to `divmod`. But the algorithm works prefectly well in other bases, for example base 4, or 8.

Python style pseudo-code of the above algorithm (base 10):

```
def div13(n):
    while n > 40:
        q, r = n // 10, n % 10
        n = q + 4*r
    return n in [13, 26, 39]

```

In base 2:

```
def div13(n):
    while n > 40:
        q, r = n >> 1, n & 1
        n = q + 7*r
    return n in [13, 26, 39]

```

In base 4:

```
def div13(n):
    while n > 40:
        q, r = n >> 2, n & 3
        n = q + 10*r
    return n in [13, 26, 39]

```

In base 8:

```
def div13(n):
    while n > 40:
        q, r = n >> 3, n & 7
        n = q + 5*r
    return n in [13, 26, 39]

```

etc. Any base smaller than 13 works equally well.

# Answer
> 2 votes
## Javascript: 59\*0.8 = 47.2 (?)

fiddle:

```
function r(n){
  for(c=0;n>c;n-=12,c++);
  return n==c?'yes':'no';
}

```

---

Including mellamokb's improvement (57\*0.8 = 45.6):

```
function r(n){
  for(c=0;n>c;n-=12,c++);
  return n-c?'no':'yes'
}

```

# Answer
> 2 votes
**Perl: (51-4 spaces)\*0.9 = 42.3**

```
say+<>%(scalar reverse int 40*atan2 1,1)?'no':'yes'

```

> 40\*atan2(1,1) -\> 31.41592 (PI\*10)

# Answer
> 2 votes
# Perl (19.8)

21 bytes * .9

```
say2*<>%26?"no":"yes"

```

*note:* My first Perl program ever. Weakly typed is good for golf i guess.

# Answer
> 2 votes
**in C (K&R): 47 * 0.8 = 37.6**

```
f(i){for(;i>0;i-=__LINE__);puts(i?"no":"yes");}

```

EDIT1: okay removed all dependencies on external functions, the above will work as long as you put this line on the 13th line of the file! :) If `__LINE__` is okay to be replaced by say `0xd` then can save a further 5 characters (score: 33.6)

# Answer
> 2 votes
## Ruby (50 48 * 0.9 = 43.2)

Smart way to use `eval`

```
eval x="p gets.to_i*3%x.length == 0? 'yes':'no'"

```

# Answer
> 2 votes
## J - 22.4 = 28 * 0.8

Based on mxmul's clever cyclic method.

```
f=:<:{('yes',~12 3$'no ')$~]

```

Examples:

```
   f 13
yes
   f 23
no
   f 13*513
yes
   f 123456789
no

```

# Answer
> 2 votes
# JavaScript (108 less 0 for whitespace) =\> 108, x 0.8 (no modulus, no division) = 86.4

`b=b=>{a=z,a=a+"";return+a.slice(0,-1)+4*+a.slice(-1)};z=prompt();for(i=99;i--;)z=b();alert(b()-z?"no":"yes")`

This method uses the following algorithm: 1. Take the last digit, multiply it by four, add it to the rest of the truncated number. 2. Repeat step 1 for 99 iterations... 3. Test it one more time using step 1, if the resulting number is itself, you've found a multiple of 13.

Previous update, removed `var`, and reversed logic at the alert to remove more chars by using subtraction-false conditional.

Technically, the end result is that you'll eventually reach a two digit number like 13, 26, or 39 which when run through step 1 again will give 13, 26, or 39 respectively. So testing for iteration 100 being the same will confirm the divisibility.

# Answer
> 2 votes
# Cheddar, 20 bytes (noncompeting)

### Score is 20 * 0.9 = 18

```
n->n*2%26?'no':'yes'

```

A straightforward answer.

# Answer
> 2 votes
# Common Lisp (71 bytes * 0.8) = 56.8

Simple recursion, really.

`(defun w(x)(if(> x 14)(w(- x 13))(if(> 14 x 12)(print'yes)(print'no))))`

Ungolfed:

```
(defun w (x)
  (if (> x 14)
      (w (- x 13))
      (if (> 14 x 12)
          (print 'yes)
          (print 'no))))

```

# Answer
> 1 votes
## D 56 chars .80 bonus = 44.8

```
bool d(double i){
    return modf(i*0,0769230769,i)<1e-3;
}

```

this might have been a cop-out with using 1/13 and a double can store any 32 bit number exactly

edit: this works by multiplying with 1/13 and checking the fractional part if it's different from 0 (allowing for rounding errors) or in other words it check the fractional part of i/13

# Answer
> 1 votes
## Python 2.7

(20 - 1 whitespace) * 0.9 (no division) = **17.1**

```
print input()%015==0

```

yes/no instead of true/false: 31 * 0.9 (no division) = **27.9**

```
print'yneos'[input()%015!=0::2]

```

takes advantage of python's `int` to convert other bases from strings into base 10 integers. you can see in both versions they use a different (yet same character length) base

edit: 1 char save in yes/no version

edit2: another 2 chars shaved!

edit3: thanks again to comments! even more characters shaved off by using python's builtin octal representations (`015` == `13`...) instead of int's base translation

# Answer
> 1 votes
# Python - score 27.9

**(31 characters * 0.90)** -- forgoes some bonus for shorter code.

```
print'yneos'[2*input()%26>0::2]

```

**older version:** (47 characters * 0.80) -- complete rip-off of mellamokb's Javascript answer, but in Python.

```
n=2*input()
while n>0:n-=26
print'yneos'[n<0::2]

```

**older version:** (60 characters * 0.80)

```
n=input()
while n>12:
 for _ in'x'*12+'!':n-=1
print'yneos'[n>0::2]

```

**older version:** (105 characters * 0.80)

```
n=abs(input())
while n>12:n=abs(sum(int(x)*y for x,y in zip(`n`[::-1],n*(1,-3,-4,-1,3,4))))
print'yneos'[n>0::2]

```

# Answer
> 1 votes
## Perl, 95 * 0.8 = 76

```
$_=<>;
while($_>0){
$q=7*chop;
$d=3*($m=chop$q);
chop$d;
$_-=$d+$m}
if($_){print"no"}
else{print"yes"}

```

The line breaks were added for clarity. I could have probably made this answer a lot shorter, but I feel that this answer represents a unique way of approaching the problem.

# Answer
> 1 votes
## In Q:

```
d:{$[0=x mod "I"$((string 6h$"q")[1 2]);`yes;`no]}
50*.9=45

```

# Answer
> 1 votes
# **Right Linear Grammar - ∞ points**

```
S->ε
S->1A
S->0S
S->9I
S->3C
S->5E
S->4D
S->2B
S->7G
S->6F
S->8H
F->3K
K->0F
A->2L
K->1G
A->5B
A->0J
B->7A
J->5A
G->6K
G->8S
H->9K
F->5S
K->2H
I->6E
I->5D
J->4S
D->8I
B->6S
K->9B
F->6A
G->9A
K->6L
K->4J
C->1E
L->8K
E->5C
B->4K
C->0D
J->2K
D->2C
A->9F
J->7C
C->6J
C->8L
E->0K
L->0C
B->9C
E->2S
L->6I
I->0L
J->0I
B->2I
I->3B
H->1C
I->7F
C->4H
F->1I
G->4I
I->0G
C->3G
F->8C
D->0A
E->3A
I->9H
A->7D
C->2F
H->7I
A->8E
F->9D
E->8F
A->6C
D->6G
G->0E
D->5F
E->9G
H->2D
D->7H
H->3E
I->2A
K->3I
C->9S
C->7K
E->4B
D->1B
L->1D
J->9E
I->1S
E->1L
J->8D
D->9J
L->2E
J->3L
B->5L
B->8B
L->7J
L->9L
G->1F
A->4A
K->5K
B->3J
H->6H
E->7E
J->1J
D->4E
G->2G
J->6B
D->3D
E->6D
H->4F
I->4C
C->5I
F->0H
H->5G
K->7S
G->3H
L->5H
H->8J
A->3S
H->0B
B->1H
G->7L
K->8A
F->2J
F->7B
L->4G
F->4L
A->1K
B->0G
G->5J
L->3F

```

Then depending on how you choose to 'run' it, it will output 'yes' or 'no'.

Not a serious entry, just some fun ;)

**EDIT:** Perhaps I should explain a bit.

A grammar is a set of rules (productions) which define a language. A language can be thought of as all of the possible strings formed by an alphabet, that conform to the rules of it's grammar.

Here the alphabet is the set of all decimal digits. The grammar's rules are that all strings must form decimal integers that are divisible by 13.

We can use the grammar above to test whether a string belongs to our language.

The rules of the grammar contain terminal symbols (which are elements in the language) as well as non-terminal symbols which are replaced recursively.

It's easier to explain what's going on with an example:

Lets say for example that the string we are testing is 71955.

There is always a start symbol (which is non-terminal), in the case of the grammar above this is 'S'. At this point we have not read any characters from our string:

```
current pattern                    symbol read
S                                  ε

```

Now, we read the first symbol in our string which is '7', then we look for a rule in the grammar which has any of the non-terminals in our current pattern in the left hand side of the '-\>' and that has our symbol in the right hand side of the '-\>'. Luckily there is one (S-\>7G), so we replace the non-terminal symbols in our current pattern with the right hand side of the new rule:

```
current pattern                    symbol read
7G                                 7

```

Now we have the non-terminal 'G' in our pattern, and the next symbol to be read is '1', So we look for a rule in our grammar that begins with 'G-\>1". We find there is one (G-\>1F), so we replace the non terminal with the RHS of our new rule:

```
current pattern                    symbol read
71F                                1

```

Keep repeating this process:

Next rule: F-\>9D

```
current pattern                    symbol read
719D                               9

```

Next rule: D-\>5F

```
current pattern                    symbol read
7195F                              5

```

Next rule: F-\>5S

```
current pattern                    symbol read
71955S                             5

```

At this point we have no more symbols in our string, but we have another non-terminal symbol in there. We see from the first rule in the grammar that we can replace 'S' with the empty string (ε): S-\>ε

Doing so gives us the current patter: 71955ε which is the equivalent to 71955.

We have read all of the symbols in our string, and the pattern contains no non-terminal symbols. Which means that the string belongs to the language and therefore 71955 is in fact divisible by 13.

I.e. the goal is to have pattern = string. If you are left with any non-terminal symbols, after reading all of the symbols in your string, the string doesnt belong to the language. Likewise, if you still have more symbols in your string to read, but there are no rules in the grammar allowing you to go forward, then the string does not belong to the language.

# Answer
> 1 votes
49 characters in Burlesque: `0\/r@{1\/.-<-12\/.-<-}{L[1.>}w!L[{"no" "yes"}\/!!` (assuming the number to check is already on the stack. see here in action.)

Does not use division, does not use modulo. It actually does not use any arithmetic at all... just list manipulation.

# Answer
> 1 votes
# Mathematica 26\*.9 ==23.4

```
If[2 n~Mod~26 == 0, "yes", "no"]

```

# Answer
> 1 votes
# Delphi XE3 114\*0.8 = 91.2

```
function d(n:integer):string;var i:int8;begin d:='No';while n>0do for I:=0to 5do n:=n-2;if n=0then exit('Yes')end;

```

### Ungolfed

```
function d(n:integer):string;
var
  i:int8;
begin
  d:='No';
  while n>0do
    for I:=0to 5do
      n:=n-2;
  if n=0then exit('Yes')
end;

```

Does not use division, does not use mod, does not contain the number 13

# Answer
> 1 votes
# Python 2: 33 * 0.9 = 29.7 points

```
print['yes','no'][input()*2%26>0]

```

`n*2%26` is equivalent to `n%13`. `input()*2%26` will give a number from 0 to 12, and only numbers with 0 should print `yes`. To solve that, we add `>0`. `0>0 == False` but `all(map(lambda n:n>0,range(1, 13))) == True`. `False` gets implicitly converted to `0`, and `True` to `1`, and the string in the appropriate index is printed.

# Answer
> 1 votes
# Python2.7, 57B

```
x=input()
while x>50:x=x//10+x%10*4
print x==x//10+x%10*4

```

No \*2%26 ~~bullshit~~ trickery here. I think it would be more interesting if all non-zero multiples of 13 were forbidden.

Alternative (per wikipedia) algorithm in slightly more interesting code in 77B:

```
print not(sum([int(s)*[1,-3,-4,-1,3,4][i%6]for i,s in enumerate(`x`[::-1])]))

```

# Answer
> 1 votes
**C#** 98 chars (score 98\*.80 = 76.8)

Shorter version:

```
int l="ThisIsLongNo?".Length;while(i>0)i-=l;if(i==0)Console.Write("yes");else Console.Write("no");

```

Easy to read version:

```
int length = "ThisIsLongNo?".Length;
while (input > 0)
    input -= length;
if (input == 0)
    Console.Write("yes");
else
    Console.Write("no");

```

# Answer
> 1 votes
# BASH, 57.6 (72\*0.8) 58.4

The x file:

```
set - `factor $1` 17
shift
while(($1<12))
do
    shift
done
(($1>16)) && echo no || echo yes

```

The size:

```
$ cat x | tr -d ' \t\n' | wc -c
72

```

The run:

```
$ for i in 1 12 13 14 142 143 144 4294967295; do echo $i - $(bash x $i) ; done
1 - no
12 - no
13 - yes
14 - no
142 - no
143 - yes
144 - no
4294967295 - no

```

# Answer
> 1 votes
PHP ~84 characters.`$n=26;// e.g.
function m($n){$x=ord(4)/4;while($n>=$x){$n-=$x;}return $n|0;}echo m($n)?'no':'yes';`

I actually prefer this method for getting 13 though (below in function form): `function a(){
 return (int)((int)true.floor(pi()));
}`

# Answer
> 1 votes
## Javascript, ES6, 74.4

Program **106\*.8 = 84.8**:

```
alert((f=n=>(n=n.toString(14).split("").reduce((r,x)=>+("0x"+x)+r,0))<14?n>12?"yes":"no":f(n))(+prompt()))

```

Function **93\*.8 = 74.4**:

```
f=n=>(n=n.toString(14).split("").reduce((r,x)=>+("0x"+x)+r,0))<14?alert(n>12?"yes":"no"):f(n)

```

The number in base 14 is divisible by 13 if and only if sum of its digits is divisible by 13.
Repeat summing digits until number will be 1 digit in base 14.
The answer is "yes" when this number is 13 or 0.
We can ignore 0 as it can be in result only when initial number is 0 (which is out of range by the rules), so it have to be greater than 12.

No explicit divisions and modulus, no any whitespaces, also no 13 in any form.

# Answer
> 1 votes
# Befunge, 27 non-whitespace bytes * 0.9 = 24.3

```
"_v#%\*4"#&<@,,<"no
  >"sey",      ^

```

Multiplies the input by 4, then checks whether the result is divisible by 52. The 4 and the 52 both come from the `4` literal in the code, which is used for its ASCII value of 52 when read from left to right, then as the number 4 when read from right to left after the `<` reverses direction.

# Answer
> 0 votes
# Ruby 34x0.8 = 27.2

```
p gets.to_i.gcd(0xD)==0?"yes":"no"

```

# Answer
> 0 votes
**Ocaml**

```
let p n =
   if ((n>0) &&(n mod (40 mod 27)) = 0) then "yes" else "no"

```

13 = x+13 mod x.

# Answer
> 0 votes
# JavaScript, Score ~~73~~ 68\*0.8=~~58.4~~ 54.4

```
for(i=prompt();(i=(i&15)+3*(i>>4))>16;);alert(((i+3)&15)?"no":"yes")

```

# Answer
> 0 votes
99 * 0.9 = 89,1 (Used division but no mod)

```
var = float.Parse(Console.ReadLine())* 2 / 26;
if (s == (int)s) Console.Write("Yes");
else Console.Write("No");

```

This is in C#. Probably not a very good language to golf in. Feel free to improve it in different languages (or in c#) aslong as the method is the same.

# Answer
> 0 votes
PYTHON 2.6

Now, this is not the shortest code, but the idea should be very easy to comprehend. Does not work with n = 0 but that can be fixed with `if not n or s[-2:] == '.5' or '.' not in s`.

```
def foo(n):
    s = str(n/26.0)
    return 'yes' if s[-2:] == '.5' or '.' not in s else 'no'

```

# Answer
> 0 votes
# C Language

```
include <stdio.h>

void main()
{
int number = 45;
int i=0;

while(number >=12)
{
for(i=0;i<=12;i++)
    number -=1;
}

if (number==0)
  printf("Divisible");
else
  printf("Not Divisible");
}

```

# Answer
> 0 votes
# QBasic - 164 CHARS

```
i = 9
s = 0
WHILE s < i
        s=s+NOT-14
        IF s=i THEN
                ? "YES"
        ELSEIF s > i THEN
                ? "NO"
        END IF
WEND

```

Set i to the number you want to test. Will Print Y if divisible by 13, otherwise, will print no. Updated to not use simple addition for to generate 13. Actual Non-Whitespace Characters is 66. No Division. No Modulus.

## SCORE 53.49

# Answer
> 0 votes
## Python, 108 x 0.8 = 86.4

```
def F(n):s=oct(n);return F(abs(sum(int(s[-1-i])*[1,-5,-1,5][i&3]for i in range(len(s)))))if n>7 else'yneos'[n>0::2]

```

Not going to win, but does an interesting trick by iterating over the octal digits of the number and reducing them modulo 13 (e.g. the "hundreds" digit is multiplied by -1 since 8^2==12==-1 mod 13).

# Answer
> 0 votes
# Q, 30 * 0.9 = 27

```
{$[0=x mod "i"$"\r";`yes;`no]}

```

# Answer
> 0 votes
## Perl, score: ~~25.6~~ 24.8

OK, my program abuses perl's **regex engine**. It's a little bit obfuscated to look funnier.

```
say+(q x x x <>)=~m ?^(\?:             )+$??"yes":"no"

```

A shorter and "more readable" version would look like this:

```
say+(" "x<>)=~/^(             )+$/?"yes":"no"

```

I'm not quite sure how to count this. I ignore whitespace, so it goes down to these ~~32~~ 31 countable characters:

```
say+(""x<>)=~/^()+$/?"yes":"no"

```

which of course doesn't work, but the rules are like that. Because there's no modulus or division, I use factor *0.8*. Please correct me if I'm wrong here. :)

# Answer
> 0 votes
# perl, 228.8 (286 chars)

This solution is long, but it's fun. It contains no cheapo, oddball representation of 13 whatsoever. It doesn't use division or modulus. It works on any integer of any length and runs in - O(log²n) time.

In all its glory:

```
@x=(1,10,9,12,3,4);sub a{$a=shift;$b=0;$c=0;for(0..length($a)-1){$c=0 if$c==6;$b+=$x[$c++]*substr$a,length($a)-$_-1,1}$b}sub b{my$c;$d=shift;do{$c=$d;$d=a$c}while($d!=$c);$x[1]=-3;$e=a$c;$x[1]=10;abs$e}sub c{@d=split//,sprintf"%02d",b$_[0];$d[0]*3==$d[1]}$\=$/;print c(abs<>)?"yes":"no"

```

Oh wait, was this not an obfuscation contest? Oops =)

Anyway, here's how it works: First, we note that the ones digit is the same modulo 13 as the millions digit, and the tens digit is the same modulo 13 as the ten millions, etc. This yields the sequence (1,10,9,12,3,4). So, we sum (sequence\[digit\_number % 6\])\*digit\_value. That gives us a smaller number that is the same modulo 13 as our input. We keep doing this until we fail to get a smaller number. Any number that fails to get smaller must be in the range 0-99. So now we take that number and feed it in to the same algorithm after changing the value for the tens digit from 10 to -3 (which is the same modulo 13). This yields a number in the range -27 to 9. If a number is a multiple of -13, it is a multiple of 13 as well, so we return the absolute value, yielding a number in the range 0-27. The multiples of 13 in the 0..27 range are 0, 13, and 26. 13 and 26 have the property that the tens digit * 3 == the ones digit. If 0 is represented as 00, it has this property as well. No other number in the range 0..27 has this property. Thus, we've determined if the input number is a multiple of 13 or not.

# Answer
> 0 votes
## JavaScript: 74\*0.8 = 59.2

```
function a(b){alert(eval(String.fromCharCode(98,37,49,51))==0?'Yes':'No')}

```

Try it out here

# Answer
> 0 votes
# PHP, Score: 64 - 20% = 51.2

```
$a=$argv[0];while($b-$i<$a){$b+=14;$i++;}echo($b-$i==$a?yes:no);

```

14 is added to `$b` in every cycle, and then it check if `$b-$i` (where `$i` is the n° of cycles) is greater of equal the input number. If it is equal, it is a multiple of 13, otherwise it's not.

# Answer
> 0 votes
# Python- 38 chars

I hope this doesn't count as a cop-out, but here it goes:

```
print["no","yes"][input()%ord("\x0D")==0]

```

Explanation:

```
                          ord("\x0D")       ---i.e. 13
                  input()%ord("\x0D")==0    ---the divisibility check
     ["no","yes"][input()%ord("\x0D")==0]   ---the bool we get is used as an index
print["no","yes"][input()%ord("\x0D")==0]   ---and we print the result

```

# Answer
> 0 votes
# Julia, 30\*0.9=27

```
f(x) = x%endof("            ")==0?"yes":"no"

```

# Answer
> 0 votes
# PowerShell: 65.6

Characters: 82
Multiplier: 0.8 (No modulus or division.)
Total: 65.6

**Golfed Code**

```
for($y=read-host;$x-lt$y;$x+='StackExchange'.length){}if($x-eq$y){"yes"}else{"no"}

```

**Un-Golfed & Commented**

```
# Set up a for loop to add 13 (derived from the length of a string) to an initially null variable ($x) until it meets or exceeds a user-input value ($y).
for($y=read-host;$x-lt$y;$x+='StackExchange'.length){}

# After for loop exits, check final value of $x against $y.
# If values match, $y is divisible by 13.
if($x-eq$y){"yes"}else{"no"}

```

If you're going to use a string length to get to 13, you may as well make the string interesting.

(May take a long time for very large values of $y.)

# Answer
> 0 votes
## Pure Bash 40=50\*0.8

File `x`:

```
j=$1*2
while ((j>0))
do
((j-=26))
done && echo no || echo yes

```

Use as, e.g., `bash x 13` or `bash x 14`. Character count:

```
$ tr -d '[:space:]' < x | wc -c
50

```

---

Older was:

File `x`:

```
for ((j=$1*2;j>0;j-=26))
do
:
done
((j)) && echo no || echo yes

```

Use as, e.g., `bash x 13` or `bash x 14`. Character count:

```
$ tr -d '[:space:]' < x | wc -c
52

```

# Answer
> 0 votes
# C#, 74 * 0.8 = 59.2

```
void f(int n)
{
    while (n >= 14)
        n = (n >> 1) + 7 * (n & 1);

    Console.Write(n <= 12 ? "no" : "yes");
}

```

**Explanation**

Write *n* as *n = 2 a + b*, i.e. *a = n / 2 = (n \>\> 1)* and *b = n % 2 = (n & 1)*

```
n          = 0    (mod 13)
2 a + b    = 0    (mod 13)
14 a + 7 b = 0    (mod 13)
a + 7 b    = 0    (mod 13)

```

So *n* is divisible by 13 if (and only if) *a + 7 b* is. Replace *n* by *a + 7 b*. Keep doing this until *n* is smaller than 14. *n* is now 13 if the starting value was divisble by 13 else *n* is some positive number smaller than 13.

# Answer
> 0 votes
# ~-~! - 38 * 0.9 (no modulus) = 34.2

```
'=~~~~,~~~+~:''=|*/','==*[|yes|]|no||:

```

~-~! only supports integer division - thus, `*/','` (`x/13*13`)is equivalent to `*-*;'` (`x-x%13`). This checks whether `x/13*13 == x` and returns the appropriate string (yeah, it's a function, decimal console input is a huge pain)

# Answer
> 0 votes
# k2, 22 char * 0.8 = 17.6

Just as you can sum the digits of a base 10 number to tell if it is divisible by 9, so too can you tell if a number is divisible by 13 if repeatedly summing its digits gives 13. As a function returning a string:

```
$`no`yes@12<(+/14_vs)/

```

`14_vs` expands the input into base 14, and then `+/` sums up the "digits". Wrapping that up into `(...)/` repeats the process until it produces no change, that is, the result is less than 14. then we simply check whether our result is greater than 12 with `12<`, and select the string "yes" or "no" (`$`no`yes@`) based on that result.

```
  $`no`yes@12<(+/14_vs)/ 39
"yes"
  f:$`no`yes@12<(+/14_vs)/
  f 38
"no"
  f' 167 168 169 170 171
("no"
 "no"
 "yes"
 "no"
 "no")
  f 0
"no"

```

0 gives a "no" under this algorithm, but that's okay because the input is always greater than 0, according to the question. If we had to fix that, we would want to increment the number before and check for equality to 1, getting the **23 character** `$`no`yes@1=(+/14_vs)/1+`.

# Answer
> 0 votes
# Powershell, 43.2

```
param($a)if((1.2307692307*$a)-band15){"no";exit}"yes"

```

Ungolfed

```
param($a)
if((1.2307692307 * $a) -band 15) {"no";exit}
"yes"

```

Magic number is of course 16/13. Multiplies by this, checks if the last four bits are all zero.

# Answer
> 0 votes
## GAP, 45 bytes * 0.8 = 36

Instead of giving one more solution that computes `Gcd(26,n)`, I multiply with the one of the field with 169 elements (which has characteristic 13) and get zero iff n is divisible by 13. If I wanted a truthy result, I could just use `IsZero`, but to get a yes/no-String I turn that result into an ordinary integer, compute 0 to that power, add one and use that as index to a string list. Normally I could say `list[index]`, but that doesn't work with list literals. However there is another short way:

```
n->\[\](["no","yes"],1+0^Int(n*One(GF(169))))

```

# Answer
> 0 votes
# Befunge, 121 bytes * 0.8 = 96.8

```
&:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-:!#v_1-       #
yes"<      >      >      >      >      >      >      >      >      >      >      >      >"on",,@,,,"

```

Uses the wraparound nature of Befunge's code--the top row repeatedly decrements the input number until reaching 0. When it reaches 0, it takes the next `v` down to the bottom row, where it either hits the one `<` or one of the twelve `>`s. The bottom row outputs "yes" if executed from right to left, and "no" from left to right.

# Answer
> 0 votes
# JavaScript, 113 Bytes

```
var input = document.querySelector("input").value;if(input/parseInt(atob("MTM=")) != 0) {alert(0);}else{alert(1)}

```

```
var input = document.querySelector("input").value;
if(input/parseInt(atob("MTM=")) != 0) {alert(0);}else{alert(1)}
```

```
<input>
```

# Answer
> 0 votes
# R, 79 Bytes

```
f=function(n)ifelse(any(1:n*as.integer(IQR(rnorm(100000,,10)))==n),"yes","no")

```

Relies on the interquartile range of a standard normal being a bit higher than 13.

ungolfed

```
f=function(n) {
    number=as.integer(IQR(rnorm(10000,,10)))
    seq=1:n*number
    if (any(seq==n)) {
        return("yes")
    } else {return("no")}
}

```

---
Tags: code-golf, restricted-source
---


title: Create a Twitter Parser

text:
# Question
Title: Create a Twitter Parser
## Introduction

You use Twitter (let's pretend, if not), where you are limited to 140 characters per individual tweet you care to share with the world. If you wanted to tweet to your followers Abraham Lincoln's Gettysburg Address, then you would need to break up the text into multiple 140-character chunks in order to get the whole message out. However, those chunks should not always be exactly 140 characters long. Say for example, we broke the speech into 17-character chunks, we'd end up with these tweets:

* FOUR SCORE AND SE
* VEN YEARS AGO OUR
* FATHERS BROUGHT
* FORTH ON THIS CON
* TINENT A NEW NATI
* ON CONCEIVED IN L
* *(and so on)*

**That's no good!** When individual words are broken up, then it can get difficult to understand what you are trying to say. Also, in the twitterverse, one of your followers may come across a specific tweet and not realize that there's more to the message, so you'll want to number your tweets so they have some context to work with (still using 17-character chunks):

* (1/7) FOUR SCORE AND
* (2/7) SEVEN YEARS AGO
* (3/7) OUR FATHERS
* (4/7) BROUGHT FORTH ON
* (5/7) THIS CONTINENT A
* (6/7) NEW NATION
* (7/7) CONCEIVED IN...

You could manually figure out the best configuration for your tweets by hand, but that's what we have computers for!

## Challenge

In the shortest code possible, parse the Gettysburg Address (or any text, but we'll stick with this one as an example) into a set of tweets consisting of no more than 140 characters (assume ASCII, since our example text should not have any uncommon/unusual bits in it).

## Details

* Your function/program/etc should take in a single string argument and output one line of text for each tweet.
    + Assume this input will never result in more than 99 total tweets when parsed, regardless of how you choose to parse (so long as that choice still fits the other points of the challenge).
* Tweets need to include a `tweet number` of `total tweets` indicator in the format "`(x/y)`" preceding the body of the tweet.
    + **This count will take up part of your 140-character space!**
* Tweet chunks may only be split on newlines or spaces.
    + No hyphens, periods, commas or other punctuation is allowed, unless immediately preceded or followed by a space or newline.
* Tweets should consist of as many complete words as possible.
    + This constraint is a little flexible, e.g. when your final tweet only has one word
* This is code golf, so the shortest code wins.

## Full Text of Gettysburg Address

<sub>(Your code should still be able to handle any ASCII string passed to it.)</sub>

> FOUR SCORE AND SEVEN YEARS AGO OUR FATHERS BROUGHT FORTH ON THIS CONTINENT A NEW NATION CONCEIVED IN LIBERTY AND DEDICATED TO THE PROPOSITION THAT ALL MEN ARE CREATED EQUAL. NOW WE ARE ENGAGED IN A GREAT CIVIL WAR TESTING WHETHER THAT NATION OR ANY NATION SO CONCEIVED AND SO DEDICATED CAN LONG ENDURE. WE ARE MET ON A GREAT BATTLEFIELD OF THAT WAR. WE HAVE COME TO DEDICATE A PORTION OF THAT FIELD AS A FINAL RESTING PLACE FOR THOSE WHO HERE GAVE THEIR LIVES THAT THAT NATION MIGHT LIVE. IT IS ALTOGETHER FITTING AND PROPER THAT WE SHOULD DO THIS. BUT IN A LARGER SENSE WE CAN NOT DEDICATE, WE CAN NOT CONSECRATE, WE CAN NOT HALLOW, THIS GROUND. THE BRAVE MEN LIVING AND DEAD WHO STRUGGLED HERE HAVE CONSECRATED IT FAR ABOVE OUR POOR POWER TO ADD OR DETRACT. THE WORLD WILL LITTLE NOTE NOR LONG REMEMBER WHAT WE SAY HERE BUT IT CAN NEVER FORGET WHAT THEY DID HERE. IT IS FOR US THE LIVING RATHER TO BE DEDICATED HERE TO THE UNFINISHED WORK WHICH THEY WHO FOUGHT HERE HAVE THUS FAR SO NOBLY ADVANCED. IT IS RATHER FOR US TO BE HERE DEDICATED TO THE GREAT TASK REMAINING BEFORE US, THAT FROM THESE HONORED DEAD WE TAKE INCREASED DEVOTION TO THAT CAUSE FOR WHICH THEY GAVE THE LAST FULL MEASURE OF DEVOTION, THAT WE HERE HIGHLY RESOLVE THAT THESE DEAD SHALL NOT HAVE DIED IN VAIN, THAT THIS NATION UNDER GOD SHALL HAVE A NEW BIRTH OF FREEDOM, AND THAT GOVERNMENT OF THE PEOPLE BY THE PEOPLE FOR THE PEOPLE SHALL NOT PERISH FROM THE EARTH.

# Answer
**Perl, 51 Characters**

```
s#\G(.{1,132})(\s+|$)#(${\++$a}/~) $1\n#g;s#~#$a#g

```

Requires -p command line prompt, 1 char included.

Explanation: insert the count portion before and newline after word groups of up to 132 characters. Insert a placeholder (`~`) for the total, which is then replaced by a second substitution. This breaks if the message contains `~`, but one could easily use an unprintable character instead.

It cheats slightly: it always allows seven characters for the count portion, `(nn/nn)`. Really, if it is `(n/n)` it should allow two extra characters. However, an arbitrary solution to this would greatly increase the complexity of the problem.
> 12 votes

# Answer
## Python, 140

^ 140 chars was actually a coincidence.

```
def f(s):
 s=s.split();i=0;l=[]
 while s:
  i+=1;t='(%d/%%d)'%i
  while s and len(t+s[0])<140:t+=' '+s.pop(0)
  l+=[t]
 for t in l:print t%i

```

While there are words left, the solution will create new tweets from the supply of words and append them to a list. For each tweet, it will keep trying to add words until the tweet's length reaches over 140 characters. Two characters are reserved for the `total tweets`, which are filled in later as each tweet in the list is printed.

Example output:

```
(1/11) FOUR SCORE AND SEVEN YEARS AGO OUR FATHERS BROUGHT FORTH ON THIS CONTINENT A NEW NATION CONCEIVED IN LIBERTY AND DEDICATED TO THE
(2/11) PROPOSITION THAT ALL MEN ARE CREATED EQUAL. NOW WE ARE ENGAGED IN A GREAT CIVIL WAR TESTING WHETHER THAT NATION OR ANY NATION SO
(3/11) CONCEIVED AND SO DEDICATED CAN LONG ENDURE. WE ARE MET ON A GREAT BATTLEFIELD OF THAT WAR. WE HAVE COME TO DEDICATE A PORTION OF THAT
(4/11) FIELD AS A FINAL RESTING PLACE FOR THOSE WHO HERE GAVE THEIR LIVES THAT THAT NATION MIGHT LIVE. IT IS ALTOGETHER FITTING AND PROPER
(5/11) THAT WE SHOULD DO THIS. BUT IN A LARGER SENSE WE CAN NOT DEDICATE, WE CAN NOT CONSECRATE, WE CAN NOT HALLOW, THIS GROUND. THE BRAVE
(6/11) MEN LIVING AND DEAD WHO STRUGGLED HERE HAVE CONSECRATED IT FAR ABOVE OUR POOR POWER TO ADD OR DETRACT. THE WORLD WILL LITTLE NOTE NOR
(7/11) LONG REMEMBER WHAT WE SAY HERE BUT IT CAN NEVER FORGET WHAT THEY DID HERE. IT IS FOR US THE LIVING RATHER TO BE DEDICATED HERE TO THE
(8/11) UNFINISHED WORK WHICH THEY WHO FOUGHT HERE HAVE THUS FAR SO NOBLY ADVANCED. IT IS RATHER FOR US TO BE HERE DEDICATED TO THE GREAT
(9/11) TASK REMAINING BEFORE US, THAT FROM THESE HONORED DEAD WE TAKE INCREASED DEVOTION TO THAT CAUSE FOR WHICH THEY GAVE THE LAST FULL
(10/11) MEASURE OF DEVOTION, THAT WE HERE HIGHLY RESOLVE THAT THESE DEAD SHALL NOT HAVE DIED IN VAIN, THAT THIS NATION UNDER GOD SHALL HAVE
(11/11) A NEW BIRTH OF FREEDOM, AND THAT GOVERNMENT OF THE PEOPLE BY THE PEOPLE FOR THE PEOPLE SHALL NOT PERISH FROM THE EARTH.

```
> 25 votes

# Answer
### Ruby, 77 characters

```
f=->t{i=0;$><<t.gsub(/(.{1,132})([ \n]|$)/m){"(#{i+=1}/%{i}) #{$1}\n"}%{i:i}}

```

Packed the logic into a single regular expression. Output of `f[text]`:

```
(1/11) FOUR SCORE AND SEVEN YEARS AGO OUR FATHERS BROUGHT FORTH ON THIS CONTINENT A NEW NATION CONCEIVED IN LIBERTY AND DEDICATED TO THE
(2/11) PROPOSITION THAT ALL MEN ARE CREATED EQUAL. NOW WE ARE ENGAGED IN A GREAT CIVIL WAR TESTING WHETHER THAT NATION OR ANY NATION SO
(3/11) CONCEIVED AND SO DEDICATED CAN LONG ENDURE. WE ARE MET ON A GREAT BATTLEFIELD OF THAT WAR. WE HAVE COME TO DEDICATE A PORTION OF
(4/11) THAT FIELD AS A FINAL RESTING PLACE FOR THOSE WHO HERE GAVE THEIR LIVES THAT THAT NATION MIGHT LIVE. IT IS ALTOGETHER FITTING AND
(5/11) PROPER THAT WE SHOULD DO THIS. BUT IN A LARGER SENSE WE CAN NOT DEDICATE, WE CAN NOT CONSECRATE, WE CAN NOT HALLOW, THIS GROUND. THE
(6/11) BRAVE MEN LIVING AND DEAD WHO STRUGGLED HERE HAVE CONSECRATED IT FAR ABOVE OUR POOR POWER TO ADD OR DETRACT. THE WORLD WILL LITTLE
(7/11) NOTE NOR LONG REMEMBER WHAT WE SAY HERE BUT IT CAN NEVER FORGET WHAT THEY DID HERE. IT IS FOR US THE LIVING RATHER TO BE DEDICATED
(8/11) HERE TO THE UNFINISHED WORK WHICH THEY WHO FOUGHT HERE HAVE THUS FAR SO NOBLY ADVANCED. IT IS RATHER FOR US TO BE HERE DEDICATED TO
(9/11) THE GREAT TASK REMAINING BEFORE US, THAT FROM THESE HONORED DEAD WE TAKE INCREASED DEVOTION TO THAT CAUSE FOR WHICH THEY GAVE THE
(10/11) LAST FULL MEASURE OF DEVOTION, THAT WE HERE HIGHLY RESOLVE THAT THESE DEAD SHALL NOT HAVE DIED IN VAIN, THAT THIS NATION UNDER GOD
(11/11) SHALL HAVE A NEW BIRTH OF FREEDOM, AND THAT GOVERNMENT OF THE PEOPLE BY THE PEOPLE FOR THE PEOPLE SHALL NOT PERISH FROM THE EARTH.

```
> 7 votes

# Answer
## Ruby, 75

Can't beat Perl, but at least it marginally beats the other Ruby solution. Note that it prints the tweets in reverse order (the problem does not specify one).

```
f=->t,i=1{t=~/\S.{,130}\S(?!\S)/?puts("(#{i}/%d) #$&"%n=f[$',i+1])||n :i-1}

```
> 4 votes

# Answer
## VBA, 251

Tried another method... Not quite as good as my original, but I'm still working on it...

```
Sub a(s)
Dim n(99)
m=1
r=Split(StrConv(s,64),Chr(0))
For i=0 To Len(s)
If i-g>132 Then n(m)=Mid(s,g+1,u-g):i=u:g=i:m=m+1
If r(i)=" " Or r(i)=vbCr Then i=i+1:u=i
Next
n(m)=Mid(s,g+1)
For o=1 To m
Debug.Print "(" & o & "/" & m & ") " & n(o)
Next
End Sub

```

Outputs:

```
(1/11) FOUR SCORE AND SEVEN YEARS AGO OUR FATHERS BROUGHT FORTH ON THIS CONTINENT A NEW NATION CONCEIVED IN LIBERTY AND DEDICATED TO THE
(2/11) PROPOSITION THAT ALL MEN ARE CREATED EQUAL. NOW WE ARE ENGAGED IN A GREAT CIVIL WAR TESTING WHETHER THAT NATION OR ANY NATION SO
(3/11) CONCEIVED AND SO DEDICATED CAN LONG ENDURE. WE ARE MET ON A GREAT BATTLEFIELD OF THAT WAR. WE HAVE COME TO DEDICATE A PORTION OF
(4/11) THAT FIELD AS A FINAL RESTING PLACE FOR THOSE WHO HERE GAVE THEIR LIVES THAT THAT NATION MIGHT LIVE. IT IS ALTOGETHER FITTING AND
(5/11) PROPER THAT WE SHOULD DO THIS. BUT IN A LARGER SENSE WE CAN NOT DEDICATE, WE CAN NOT CONSECRATE, WE CAN NOT HALLOW, THIS GROUND. THE
(6/11) BRAVE MEN LIVING AND DEAD WHO STRUGGLED HERE HAVE CONSECRATED IT FAR ABOVE OUR POOR POWER TO ADD OR DETRACT. THE WORLD WILL LITTLE
(7/11) NOTE NOR LONG REMEMBER WHAT WE SAY HERE BUT IT CAN NEVER FORGET WHAT THEY DID HERE. IT IS FOR US THE LIVING RATHER TO BE DEDICATED
(8/11) HERE TO THE UNFINISHED WORK WHICH THEY WHO FOUGHT HERE HAVE THUS FAR SO NOBLY ADVANCED. IT IS RATHER FOR US TO BE HERE DEDICATED TO
(9/11) THE GREAT TASK REMAINING BEFORE US, THAT FROM THESE HONORED DEAD WE TAKE INCREASED DEVOTION TO THAT CAUSE FOR WHICH THEY GAVE THE
(10/11) LAST FULL MEASURE OF DEVOTION, THAT WE HERE HIGHLY RESOLVE THAT THESE DEAD SHALL NOT HAVE DIED IN VAIN, THAT THIS NATION UNDER GOD
(11/11) SHALL HAVE A NEW BIRTH OF FREEDOM, AND THAT GOVERNMENT OF THE PEOPLE BY THE PEOPLE FOR THE PEOPLE SHALL NOT PERISH FROM THE EARTH.

```
> 1 votes

# Answer
# BASH (88 Chars)

```
fold -132 -s |tac|cat -n |tac|awk '{if(NR==1)a=$1;$1="";printf "(%d/%d) %s\n",NR,a,$0 }'

```

Fold the line at 132 characters (to allow for our tweet count), on spaces (`-s`), Read text backwards (tac), number the text (`cat -n`), re-reverse (`tac`). Inside Awk: First line (NR==1), assign the letter 'a' the value in the first . Blank the number column. Print (NR/'a') then the line.

Output:

```
(1/12)  FOUR SCORE AND SEVEN YEARS AGO OUR FATHERS BROUGHT FORTH ON THIS CONTINENT A NEW NATION CONCEIVED IN LIBERTY AND DEDICATED TO THE
(2/12)  PROPOSITION THAT ALL MEN ARE CREATED EQUAL. NOW WE ARE ENGAGED IN A GREAT CIVIL WAR TESTING WHETHER THAT NATION OR ANY NATION SO
(3/12)  CONCEIVED AND SO DEDICATED CAN LONG ENDURE. WE ARE MET ON A GREAT BATTLEFIELD OF THAT WAR. WE HAVE COME TO DEDICATE A PORTION OF
(4/12)  THAT FIELD AS A FINAL RESTING PLACE FOR THOSE WHO HERE GAVE THEIR LIVES THAT THAT NATION MIGHT LIVE. IT IS ALTOGETHER FITTING AND
(5/12)  PROPER THAT WE SHOULD DO THIS. BUT IN A LARGER SENSE WE CAN NOT DEDICATE, WE CAN NOT CONSECRATE, WE CAN NOT HALLOW, THIS GROUND.
(6/12)  THE BRAVE MEN LIVING AND DEAD WHO STRUGGLED HERE HAVE CONSECRATED IT FAR ABOVE OUR POOR POWER TO ADD OR DETRACT. THE WORLD WILL
(7/12)  LITTLE NOTE NOR LONG REMEMBER WHAT WE SAY HERE BUT IT CAN NEVER FORGET WHAT THEY DID HERE. IT IS FOR US THE LIVING RATHER TO BE
(8/12)  DEDICATED HERE TO THE UNFINISHED WORK WHICH THEY WHO FOUGHT HERE HAVE THUS FAR SO NOBLY ADVANCED. IT IS RATHER FOR US TO BE HERE
(9/12)  DEDICATED TO THE GREAT TASK REMAINING BEFORE US, THAT FROM THESE HONORED DEAD WE TAKE INCREASED DEVOTION TO THAT CAUSE FOR WHICH
(10/12)  THEY GAVE THE LAST FULL MEASURE OF DEVOTION, THAT WE HERE HIGHLY RESOLVE THAT THESE DEAD SHALL NOT HAVE DIED IN VAIN, THAT THIS
(11/12)  NATION UNDER GOD SHALL HAVE A NEW BIRTH OF FREEDOM, AND THAT GOVERNMENT OF THE PEOPLE BY THE PEOPLE FOR THE PEOPLE SHALL NOT PERISH
(12/12)  FROM THE EARTH.

```
> 1 votes

# Answer
## Javascript (FF only), 92 chars

```
r=(s)=>{s.match(/.{1,132}(\s|$)/gm).map((v,i,a)=>console.log(v,'('+(i+1)+'/'+a.length+')'))}

```

Formatted, that's a rip-off of the Perl script:

```
r=(s)=>{
    s.match(/.{1,132}(\s|$)/gm).map((v,i,a) => console.log(v,'('+(i+1)+'/'+a.length+')'))
}

```
> 1 votes

# Answer
## VBA, 227

```
Sub a(s)
Dim n(99)
m=1
x=133
While Len(s)>x
t=Left(s,x):p=InStrRev(t," "):q=InStrRev(t,vbCr):i=IIf(p>q,p,q):t=Left(s,i):s=Mid(s,i+1):n(m)=t:m=m+1
Wend
n(m)=s
For o=1 To m
Debug.Print "(" & o & "/" & m & ") " & n(o)
Next
End Sub

```

Outputs:

```
(1/11) FOUR SCORE AND SEVEN YEARS AGO OUR FATHERS BROUGHT FORTH ON THIS CONTINENT A NEW NATION CONCEIVED IN LIBERTY AND DEDICATED TO THE
(2/11) PROPOSITION THAT ALL MEN ARE CREATED EQUAL. NOW WE ARE ENGAGED IN A GREAT CIVIL WAR TESTING WHETHER THAT NATION OR ANY NATION SO
(3/11) CONCEIVED AND SO DEDICATED CAN LONG ENDURE. WE ARE MET ON A GREAT BATTLEFIELD OF THAT WAR. WE HAVE COME TO DEDICATE A PORTION OF
(4/11) THAT FIELD AS A FINAL RESTING PLACE FOR THOSE WHO HERE GAVE THEIR LIVES THAT THAT NATION MIGHT LIVE. IT IS ALTOGETHER FITTING AND
(5/11) PROPER THAT WE SHOULD DO THIS. BUT IN A LARGER SENSE WE CAN NOT DEDICATE, WE CAN NOT CONSECRATE, WE CAN NOT HALLOW, THIS GROUND. THE
(6/11) BRAVE MEN LIVING AND DEAD WHO STRUGGLED HERE HAVE CONSECRATED IT FAR ABOVE OUR POOR POWER TO ADD OR DETRACT. THE WORLD WILL LITTLE
(7/11) NOTE NOR LONG REMEMBER WHAT WE SAY HERE BUT IT CAN NEVER FORGET WHAT THEY DID HERE. IT IS FOR US THE LIVING RATHER TO BE DEDICATED
(8/11) HERE TO THE UNFINISHED WORK WHICH THEY WHO FOUGHT HERE HAVE THUS FAR SO NOBLY ADVANCED. IT IS RATHER FOR US TO BE HERE DEDICATED TO
(9/11) THE GREAT TASK REMAINING BEFORE US, THAT FROM THESE HONORED DEAD WE TAKE INCREASED DEVOTION TO THAT CAUSE FOR WHICH THEY GAVE THE
(10/11) LAST FULL MEASURE OF DEVOTION, THAT WE HERE HIGHLY RESOLVE THAT THESE DEAD SHALL NOT HAVE DIED IN VAIN, THAT THIS NATION UNDER GOD
(11/11) SHALL HAVE A NEW BIRTH OF FREEDOM, AND THAT GOVERNMENT OF THE PEOPLE BY THE PEOPLE FOR THE PEOPLE SHALL NOT PERISH FROM THE EARTH.

```
> 0 votes

# Answer
## Javascript (FF only), 135 chars

```
n=(s)=>{for(g=[],i=1,a=s.split(/(\s)/),r='';c=a.shift();g[i]=r+=c)if((c+r)[132]&&i++)r='';g.map((v,k)=>console.log(v,'('+k+'/'+i+')'))}

```

Formatted, that's:

```
n=(s)=>{
    for (g=[],i=1,a=s.split(/(\s)/),r=''; c=a.shift(); g[i]=r+=c) {
        if((c+r)[132]&&i++) {
            r='';
        }
    }
    g.map((v,k)=>console.log(v,'('+k+'/'+i+')'))
}

```
> 0 votes

# Answer
# PHP, 233

Am I correct in assuming that this is the first answer that does not cheat on the count portion?
(It also works with more than 99 tweets; I could shave off two more bytes if I would allow an infinite loop in that case.)

```
function t($s,$e=1){$a=explode(' ',$s);while($a){$t=++$n;while($a&&strlen($t.$a[0])<137-$e)$t.=' '.array_shift($a);$r[]=$t;}if($n>=10**$e)t($s,$e+1);else foreach($r as$i=>$s)echo preg_replace('%(^\d+)%',"(\$1/$n)",$s),'
';}

```

ungolfed:

```
function t($s,$e=1)
{
    $a=explode(' ',$s);
    while($a)
    {
        $t=++$n;
        while($a&&strlen($t.$a[0])<137-$e)$t.=' '.array_shift($a);
        $r[]=$t;
    }
    if($n>=10**$e)                  // if tweet count has more than $e digits
        t($s,ceil(log10($n+1)));    // use correct length (golfed: try with length+1)
    else
        foreach($r as$i=>$s)
            echo preg_replace('%(^\d+)%',"(\$1/$n)",$s),"\n";
}

```
> 0 votes

---
Tags: code-golf, string
---