在SO上引用此问题（扰流板警报！）：

在Oracle采访中已经问过这个问题。

如何在不使用*，/，+，-，％操作符的情况下将数字除以3？

该数字可以签名也可以不签名。

该任务是可解决的，但是请查看是否可以编写最短的代码。

规则：

• 执行所需的整数除法（/3）
• 不要使用非基于文本运营商*，/，+，-，或%（或它们的等价物，如__div__或add()）。这也适用于递增或递减运算符，例如i++或i--。可以使用运算符进行字符串连接和格式化。也可以将这些字符用于不同的运算符，例如-用于负数的一元运算符，或*在C中表示指针。
• 输入值可以为正值和负值任意大（系统可以处理的任何值）
• 输入可以在STDIN或ARGV上，也可以任何其他方式输入
• 创建最短的代码即可完成以上操作

J，45 44 10个字符

".,&'r3'":

适用于底片：

".,&'r3'": 15
5
   ".,&'r3'": _9
_3
   ".,&'r3'": 3e99
1e99

": -格式化为文本

,&'r3'-追加r3到末尾

". -执行字符串，例如 15r3

C，167503724710

这是我解决问题的方法。我承认它不可能赢得一场严格的代码高尔夫比赛，但是它并没有使用任何技巧来间接调用内置的除法功能，它是用可移植的C语言编写的（正如最初的Stack Overflow问题所要求的那样），它可以完美地运行负数，并且代码非常清晰明了。

我的程序是以下脚本的输出：

#!/usr/bin/env python3
import sys

# 71
sys.stdout.write('''#include <stdint.h>
#include <stdio.h>
int32_t div_by_3(int32_t input){''')

# 39 * 2**32
for i in range(-2**31, 2**31):
    # 18 + 11 + 10 = 39
    sys.stdout.write('if(input==%11d)return%10d;' % (i, i / 3))

# 95
sys.stdout.write(r'''return 7;}int main(int c,char**v){int32_t n=atoi(a[1]);printf("%d / 3 = %d\n",n, div_by_3(n));}''')

字符数：71 + 39 * 2 ** 32 + 95 = 167503724710

基准测试

有人问这将花费多长时间以及将使用多少内存，因此这里有一些基准测试：

• 脚本执行时间-运行./test.py | pv --buffer-size=1M --average-rate > /dev/null约30秒可获得约14.8 MB / s的速率。可以合理地假设输出速率大致恒定，因此完成运行所需的时间应约为167503724710 B /（14.8 * 1048576 B / s）≈10794 s。
• 编译时间— TCC编译器声称以29.6 MB / s的速度编译C代码，这使得编译时间为167503724710 B /（29.6 * 1048576 B / s）≈5397 s。（当然，这可以与脚本一起在管道中运行。）
• 编译后代码的大小—我尝试使用进行估算./test.py | tcc -c - -o /dev/stdout | pv --buffer-size=1M --average-rate > /dev/null，但是tcc直到它读入整个源文件后，它似乎才输出任何内容。
• 要运行的内存使用量-由于算法是线性的（并且tcc不会跨行进行优化），因此内存开销应该只有几千字节（当然，除了代码本身）。

红宝石28

b=->n{n.to_s(3).chop.to_i 3}

要除以3，我们只需要删除基数为3的尾随零即可： 120 -> 11110 -> 1111 -> 40

适用于底片：

ice distantstar:~/virt/golf [349:1]% ruby ./div3.rb
666
222
ice distantstar:~/virt/golf [349]% ruby ./div3.rb
-15        
-5

红宝石，60 45

或者，不使用基本转换：

d =-> n {x = n.abs; r =（0..1.0 / 0）.step（3）.take（x）.index x; n> 0？r：-r}

d=->n{(r=1.step(n.abs,3).to_a.size);n>0?r:-r}

Mathematica，13个字符

Mean@{#,0,0}&

JavaScript，56

alert(Array(-~prompt()).join().replace(/,,,/g,1).length)

使字符串的长度n重复,s并替换,,,为1。然后，它测量字符串的结果长度。（希望一元-允许！）

蟒蛇，41 38

print"-"[x:]+`len(xrange(2,abs(x),3))`

xrange 似乎能够立即处理大量数字（我认为限制与C语言中的long相同）。

>>> x = -72
-24

>>> x = 9223372036854775806
3074457345618258602

90岁的哈斯克尔 106

d n=snd.head.dropWhile((/=n).fst)$zip([0..]>>=ν)([0..]>>=replicate 3>>=ν);ν q=[negate q,q]

创建一个无限（懒惰）查找列表[(0,0),(0,0),(-1,0),(1,0),(-2,0),(2,0),(-3,-1),(3,1), ...]，修剪所有不匹配的元素n（/=在Haskell中是不等式），并返回第一个匹配的元素。

如果没有负数，这将变得更加简单：

25 27

(([0..]>>=replicate 3)!!)

只需返回n列表的th元素[0,0,0,1,1,1,2, ...]。

C＃，232字节

我的第一个代码高尔夫...而且由于没有C＃，并且我想尝试一种此处未尝试的其他方法，因此我想尝试一下。像这里的其他一些一样，只有非负数。

class l:System.Collections.Generic.List<int>{}class p{static void Main(string[] g){int n=int.Parse(g[0]);l b,a=new l();b=new l();while(a.Count<n)a.Add(1);while(a.Count>2){a.RemoveRange(0,3);b.Add(1);}System.Console.Write(b.Count);}}

不打高尔夫球

class l : System.Collections.Generic.List<int>
{ }
class p
{
    static void Main(string[] g)
    {
        int n = int.Parse(g[0]);
        l b, a = new l();
        b = new l();
        while (a.Count < n) a.Add(1);
        while (a.Count > 2)
        {
            a.RemoveRange(0, 3);
            b.Add(1);
        }
        System.Console.Write(b.Count);
    }
}

Perl（26 22）

$_=3x pop;say s|333||g

此版本（ab）使用Perl的正则表达式引擎。它读取一个数字作为最后一个命令行参数（pop），并构建一个3长度为s的字符串"3" x $number。正则表达式替换运算符（s///由于拼图规则而在此处使用不同的g定界符，并带有一个小叶标志，因此用空字符串替换了三个字符），并返回替换数，即输入数除以3。它甚至可以不用编写3，但是上面的版本看起来更有趣。

$ perl -E '$_=3x pop;say s|333||g' 42
14

C，160个字符

使用查找表的逐字符长除法解决方案，即不使用字符串atoi（）或printf（）在基数10的字符串和整数之间进行转换。

输出有时会包含前导零-这是魅力的一部分。

main(int n,char**a){
char*s=a[1],*x=0;
if(*s==45)s=&s[1];
for(;*s;s=&s[1])n=&x[*s&15],x="036"[(int)x],*s=&x["000111222333"[n]&3],x="012012012012"[n]&3;
puts(a[1]);
}

注意：

• 滥用数组访问以实现添加。
• 使用clang 4.0进行编译，其他编译器可能会阻塞。

测试：

./a.out -6            -2
./a.out -5            -1
./a.out -4            -1
./a.out -3            -1
./a.out -2            -0
./a.out -1            -0
./a.out 0             0
./a.out 1             0
./a.out 2             0
./a.out 3             1
./a.out 4             1
./a.out 5             1
./a.out 6             2
./a.out 42            14
./a.out 2011          0670

Python 42

int(' -'[x<0]+str(len(range(2,abs(x),3))))

由于我已在此处发布的所有解决方案都将截断小数位数，因此我的解决方案就是这样做。

Python 50 51

int(' -'[x<0]+str(len(range([2,0][x<0],abs(x),3))))

由于python进行地板分割，因此这是我实现的解决方案。

输入整数在变量x中。

在Python 2.7中进行了测试，但我怀疑它也可以在3中运行。

JavaScript，55岁

alert(parseInt((~~prompt()).toString(3).slice(0,-1),3))

如果无法使用-1，那么这里是一个用替换它的版本~0（感谢Peter Taylor！）。

alert(parseInt((~~prompt()).toString(3).slice(0,~0),3))

C 83个字符

要分割的数字通过stdin传入，并将其作为退出代码main()（在CMD中为％ERRORLEVEL％）返回。该代码滥用了某些版本的MinGW，因为在未启用优化的情况下，它将最后的赋值视为返回语句。它可能可以减少一点。支持所有可能适合的数字int

如果不允许一元否定（-）：（129）

I(unsigned a){a=a&1?I(a>>1)<<1:a|1;}main(a,b,c){scanf("%i",&b);a=b;a=a<0?a:I(~a);for(c=0;a<~1;a=I(I(I(a))))c=I(c);b=b<0?I(~c):c;}

如果一元否定IS允许：（123）

I(unsigned a){a=a&1?I(a>>1)<<1:a|1;}main(a,b,c){scanf("%i",&b);a=b;a=a<0?a:-a;for(c=0;a<~1;a=I(I(I(a))))c=I(c);b=b<0?-c:c;}

编辑：ugoren向我指出-〜是一个增量...

如果允许一元求反，则为83个字符：D

main(a,b,c){scanf("%i",&b);a=b;a=a<0?a:-a;for(c=0;a<~1;a=-~-~-~a)c=-~c;b=b<0?-c:c;}

C，139个字符

t;A(a,b){return a?A((a&b)<<1,a^b):b;}main(int n,char**a){n=atoi(a[1]);for(n=A(n,n<0?2:1);n&~3;t=A(n>>2,t),n=A(n>>2,n&3));printf("%d\n",t);}

以数字作为命令行参数运行

• 处理正数和负数

测试：

 ./a.out -6            -2
 ./a.out -5            -1
 ./a.out -4            -1
 ./a.out -3            -1
 ./a.out -2            0
 ./a.out -1            0
 ./a.out 0             0
 ./a.out 1             0
 ./a.out 2             0
 ./a.out 3             1
 ./a.out 4             1
 ./a.out 5             1
 ./a.out 6             2
 ./a.out 42            14
 ./a.out 2011          670

编辑：

• 通过改组加法（A）删除局部变量，节省了10个字符。

ZSH — 31 20/21

echo {2..x..3}|wc -w

对于负数：

echo {-2..x..3}|wc -w

带有负数（ZSH + bc）—62 61

我可能不应该给出两个程序作为答案，所以这是一个适用于任何数字符号的程序：

echo 'obase=10;ibase=3;'`echo 'obase=3;x'|bc|sed 's/.$//'`|bc

这使用了与Artem Ice的答案相同的基本转换技巧。

C，81 73个字符

仅支持非负数。

char*x,*i;
main(){
    for(scanf("%d",&x);x>2;x=&x[~2])i=&i[1];
    printf("%d",i);
}

这个想法是使用指针的。该数字将读入指针x，该指针不会指向任何地方。&x[~2]= &x[-3]= x-3用于减去3。只要数字大于2，便会重复此操作。i计算完成次数（&i[1]= i+1）。

爪哇 86 79

假设整数在y中：

在基数3中转换为字符串，删除最后一个字符（在基数3中右移“ >>”），然后转换回整数。

适用于负数。

如果数字y <3或> -3，则给出0。

System.out.print(~2<y&y<3?0:Long.valueOf(Long.toString(y,3).split(".$")[0],3));

第一次在代码高尔夫上发帖。=）所以还不能发表评论。

Thx Kevin Cruijssen给出了提示。

python2.6（29）（71）（57）（52）（43）

z=len(range(2,abs(x),3))
print (z,-z)[x<0]

print len(range(2,input(),3))

编辑-刚刚意识到我们也必须处理负整数。稍后会解决

Edit2-固定

Edit3-按照Joel Cornett的建议保存了5个字符

Edit4-由于输入不一定必须来自STDIN或ARGV，因此通过不从stdin接受任何输入来节省了9个字符

Javascript，47 29

用于eval动态生成/。使用+仅字符串连接，而不是加法。

alert(eval(prompt()+"\57"+3))

编辑：使用"\57"代替String.fromCharCode(47)

红宝石（43 22 17）

不仅高尔夫，而且优雅：)

p Rational gets,3

输出将像(41/1)。如果必须为整数，则必须.to_i加到结果中；如果更改to_i为，to_f则也可以得到浮点数的输出。

TI基本，8字节

优胜者？:)

int(mean({Ans,0,0

PS将负数四舍五入为无穷大（原因请参见此处）。要舍入为零，请替换为，int(以iPart(保持字节不变。

测试用例

-4:prgmDIVIDE
              -2
11:prgmDIVIDE
               3
109:prgmDIVIDE
              36

Python 2.x，54 53 51

print' -'[x<0],len(range(*(2,-2,x,x,3,-3)[x<0::2]))

_股息在哪里，就这样输入。

>>> x=-19
>>> print' -'[x<0],len(range(*(2,-2,x,x,3,-3)[x<0::2]))
- 6

注意：不确定是否允许使用交互式解释器，但是根据OP：“输入可以在STDIN或ARGV上或以任何其他方式输入”

编辑：现在为python 3（在2.x，但打印一个元组）。适用于底片。

C ++，191

使用main and includes，它的值为246，不使用main and includes，它只有178。换行符算作1个字符。将所有数字视为无符号。我没有因主返回一个未签名的int而得到警告，因此它是公平的游戏。

我第一次提交代码高尔夫。

#include<iostream>
#define R return
typedef unsigned int U;U a(U x,U y){R y?a(x^y,(x|y^x^y)<<1):x;}U d(U i){if(i==3)R 1;U t=i&3,r=i>>=2;t=a(t,i&3);while(i>>=2)t=a(t,i&3),r=a(r,i);R r&&t?a(r,d(t)):0;}U main(){U i;std::cin>>i,std::cout<<d(i);R 0;}

使用移位反复将数字除以4，然后计算总和（收敛到1/3）

伪代码：

// typedefs and #defines for brevity

function a(x, y):
    magically add x and y using recursion and bitwise things
    return x+y.

function d(x):
    if x = 3:
        return 1.
    variable total, remainder
    until x is zero:
        remainder = x mod 4
        x = x / 4
        total = total + x
    if total and remainder both zero:
        return 0.
    else:
        return a(total, d(remainder)).

顺便说一句，我可以通过命名d main并使其采用char **并将程序返回值用作输出来消除main方法。它将返回命令行参数的数量除以3（四舍五入）。这使它的长度达到了广告191：

#define R return
typedef unsigned int U;U a(U x,U y){R y?a(x^y,(x|y^x^y)<<1):x;}U main(U i,char**q){if(i==3)R 1;U t=i&3,r=i>>=2;t=a(t,i&3);while(i>>=2)t=a(t,i&3),r=a(r,i);R r&&t?a(r,d(t)):0;}

Golfscript-13个字符

~3base);3base

PowerShell 57或46

在57个字符中%用作PowerShell foreach运算符，而不是取模。此解决方案可以接受正整数或负整数。

(-join(1..(Read-Host)|%{1})-replace111,0-replace1).Length

如果*允许使用46个字符作为字符串重复运算符，则不能相乘。此选项需要正整数作为输入值。

("1"*(Read-Host)-replace111,0-replace1).Length

[R

这些仅适用于正整数：

max(sapply(split(1:x,1:3), length))
# Gives a warning that should be ignored

要么：

min(table(rep(1:3, x)[1:x]))

要么：

length((1:x)[seq(3,x,3)])

要么：

sum(rep(1,x)[seq(3,x,3)])

[[EDIT]]和一个丑陋的人：

trunc(sum(rep(0.3333333333, x)))

[[EDIT2]]可能是最好的之一-受上面Elliot G的matlab代码启发：

length(seq(1,x,3))

SmileBASIC，58 51 36字节（无数学函数！）

INPUT N
BGANIM.,4,-3,N
WAIT?BGROT(0)

说明：

INPUT N           'get input
BGANIM 0,"R",-3,N 'smoothly rotate background layer 0 by N degrees over 3 frames
WAIT              'wait 1 frame
PRINT BGROT(0)    'display angle of layer 0

该程序将背景层平滑移动3帧，然后在移动了其总距离的1/3时获得1帧后的角度。

浮点分割版本，38字节：

INPUT N
BGANIM.,7,-3,N
WAIT?BGVAR(0,7)

说明：

INPUT N           'input
BGANIM 0,"V",-3,N 'smoothly change layer 0's internal variable to N over 3 frames
WAIT              'wait 1 frame
PRINT BGVAR(0,7)  'display layer 0's internal variable

Haskell 41 39个字符

适用于全套正负整数

f n=sum[sum$1:[-2|n<0]|i<-[3,6..abs n]]

首先为从0到input的每三个整数创建一个列表1或（-1）（取决于输入的符号）n。abs(n)包括负数在内。

例如 n=8 -> [0,3,6]

然后，它返回此列表的总和。

Clojure，87岁；与底片一起工作；基于lazyseqs

(defn d[n](def r(nth(apply interleave(repeat 3(range)))(Math/abs n)))(if(> n 0)r(- r)))

取消高尔夫：

(defn d [n]
  (let [r (nth (->> (range) (repeat 3) (apply interleave))
               (Math/abs n))]
        (if (pos? n)
          r
          (- r))))

鼠尾草笔记本 （21）

ZZ(n.digits(3)[1:],3)