Citando esta pergunta no SO (alerta de spoiler!):

Esta pergunta foi feita em uma entrevista da Oracle.

Como você dividiria um número por 3 sem usar os operadores *, /, +, -,%?

O número pode ser assinado ou não assinado.

A tarefa é solucionável, mas veja se você pode escrever o código mais curto.

Regras:

• Execute a divisão inteira necessária ( /3)
• Não use os operadores não baseados em texto *, /, +, -, ou %(ou seus equivalentes, como __div__ou add()). Isso também se aplica a operadores de incremento e decremento, como i++ou i--. O uso de operadores para concatenação e formatação de string está OK. Usar esses caracteres para diferentes operadores, como -operador unário para números negativos, ou *para representar um ponteiro em C também é bom.
• O valor de entrada pode ser arbitrariamente grande (seja qual for o seu sistema), tanto positivo quanto negativo
• A entrada pode ser em STDIN ou ARGV ou inserida de qualquer outra maneira
• Crie o código mais curto possível para fazer o acima

J, 45 44 10 caracteres

".,&'r3'":

Trabalha com negativos:

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

": - formatar como texto

,&'r3'- anexar r3ao final

". - execute a string, por exemplo 15r3

C, 167503724710

Aqui está a minha solução para o problema. Eu admito que é improvável que ganhe uma competição estrita de golfe com código, mas não usa truques para chamar indiretamente a funcionalidade de divisão interna, ela é escrita em C portátil (como a pergunta original do Stack Overflow solicitada), funciona perfeitamente para números negativos e o código é excepcionalmente claro e explícito.

Meu programa é a saída do seguinte script:

#!/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));}''')

Contagem de caracteres: 71 + 39 * 2 ** 32 + 95 = 167503724710

Benchmarks

Foi perguntado quanto tempo isso levaria e quanta memória seria usada, então aqui estão alguns parâmetros de referência:

• Tempo de execução do script - A execução ./test.py | pv --buffer-size=1M --average-rate > /dev/nullpor cerca de 30 segundos fornece uma taxa de cerca de 14,8 MB / s. A taxa de saída pode ser razoavelmente considerada constante, portanto o tempo de execução deve ser de 167503724710 B / (14,8 * 1048576 B / s) ≈ 10794 s.
• Tempo de compilação - O compilador TCC pretende compilar o código C a 29,6 MB / s , o que resulta em um tempo de compilação de 167503724710 B / (29,6 * 1048576 B / s) ≈ 5397 s. (É claro que isso pode ser executado em um pipeline com o script.)
• Tamanho do código compilado - tentei estimar usando ./test.py | tcc -c - -o /dev/stdout | pv --buffer-size=1M --average-rate > /dev/null, mas parece tccque não gera nada até ler todo o arquivo de origem.
• Uso da memória a ser executada - Como o algoritmo é linear (e o tcc não otimiza através das linhas), a sobrecarga da memória deve ser de apenas alguns kilobytes (além do próprio código, é claro).

Ruby 28

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

Para dividir por 3, basta remover o zero à direita no número base 3: 120 -> 11110 -> 1111 -> 40

Trabalha com negativos:

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

Ruby, 60 45

Como alternativa, sem a conversão base:

d = -> n {x = n.abs; r = (0..1,0 / 0) .step (3) .take (x). índice x; n> 0? r: -r}

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

Mathematica, 13 caracteres

Mean@{#,0,0}&

JavaScript, 56

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

Faz uma sequência de nrepetições se ,substitui ,,,por 1. Em seguida, mede o comprimento resultante da string. (Espero que unário -seja permitido!)

Python, 41 38

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

xrange parece ser capaz de lidar com grandes números (acho que o limite é o mesmo que por muito tempo em C) quase instantaneamente.

>>> x = -72
-24

>>> x = 9223372036854775806
3074457345618258602

Haskell, 90 106

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

Cria uma lista de pesquisa infinita (lenta) [(0,0),(0,0),(-1,0),(1,0),(-2,0),(2,0),(-3,-1),(3,1), ...], apara todos os elementos que não correspondem n( /=há desigualdade em Haskell) e retorna o primeiro que corresponde.

Isso fica muito mais simples se não houver números negativos:

25 27

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

simplesmente retorna o nth elemento da lista [0,0,0,1,1,1,2, ...].

C #, 232 bytes

Meu primeiro código de golfe ... E como não havia nenhum C # e eu queria tentar um método diferente não tentado aqui, pensei em tentar. Como alguns outros aqui, apenas números não negativos.

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);}}

Ungolfed

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

Esta versão (ab) usa o mecanismo de expressão regular do Perl. Ele lê um número como o último argumento da linha de comando ( pop) e cria uma sequência de 3s deste comprimento ( "3" x $number). O operador de substituição de expressão regular ( s///aqui escrito com delimitadores diferentes por causa das regras do quebra-cabeça e com uma gbandeira global) substitui três caracteres pela string vazia e retorna o número de substituições, que é o número de entrada inteiro dividido por três. Poderia até ser escrito sem 3, mas a versão acima parece mais engraçada.

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

C, 160 caracteres

Solução de divisão longa caractere a caractere usando tabelas de pesquisa, ou seja, sem a seqüência atoi () ou printf () para converter entre as seqüências base 10 e os inteiros.

Às vezes, a saída inclui um zero inicial - parte de seu charme.

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]);
}

Nota:

• abusa do acesso à matriz para implementar a adição.
• compila com o clang 4.0, outros compiladores podem vomitar.

Testando:

./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))))

Como todas as soluções postadas aqui que eu verifiquei truncam casas decimais aqui é a minha solução que faz isso.

Python 50 51

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

Como o python faz a divisão de pisos, eis a minha solução que implementa isso.

O número inteiro de entrada está na variável x.

Testado em Python 2.7, mas suspeito que funcione em 3 também.

JavaScript, 55

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

Se alguém não pode usar -1, então aqui está uma versão substituindo-a por ~0(obrigado Peter Taylor!).

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

Caracteres C 83

O número a ser dividido é passado através de stdin e o retorna como o código de saída de main()(% ERRORLEVEL% no CMD). Esse código abusa de algumas versões do MinGW, pois quando as otimizações não estão ativadas, ele trata o último valor da atribuição como uma declaração de retorno. Provavelmente pode ser um pouco reduzido. Suporta todos os números que podem caber em umint

Se o negativo unário (-) não for permitido: (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;}

Se for negado unário, é permitido: (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;}

EDIT: ugoren apontou para mim que - ~ é um incremento ...

83 caracteres se a negação unária for permitida: 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 caracteres

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);}

Executar com número como argumento da linha de comando

• Lida com números negativos e positivos

Testando:

 ./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

Editar% s:

• salvou 10 caracteres ao embaralhar a adição (A) para remover variáveis ​​locais.

ZSH - 31 20/21

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

Para números negativos:

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

Com números negativos (ZSH + bc) -62 61

Eu provavelmente não deveria dar dois programas como minha resposta, então aqui está um que funciona para qualquer sinal de número:

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

Isso usa o mesmo truque de conversão de base da resposta de Artem Ice .

C, 81 73 caracteres

Suporta apenas números não negativos.

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

A idéia é usar o ponteiro aritêmico. O número é lido no ponteiro x, que não aponta para lugar nenhum. &x[~2]= &x[-3]= x-3é usado para subtrair 3. Isso é repetido desde que o número esteja acima de 2. iconta o número de vezes que isso é feito ( &i[1]= i+1).

Java 86 79

Suponha que o número inteiro esteja em y:

Converte em uma string na base 3, remove o último caractere (shift à direita ">>" na base 3) e depois converte novamente em número inteiro.

Funciona para números negativos.

Se o número, y, é <3 ou> -3, fornece 0.

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

Primeira postagem no código de golfe. =) Portanto, não posso comentar ainda.

Obrigado Kevin Cruijssen pelas dicas.

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))

Editar - Acabamos de perceber que também precisamos lidar com números inteiros negativos. Consertará isso mais tarde

Edit2 - Fixed

Edit3 - Salvo 5 caracteres seguindo o conselho de Joel Cornett

Edit4 - Como a entrada não precisa ser necessariamente de STDIN ou ARGV, salvou 9 caracteres por não receber nenhuma entrada de stdin

Javascript, 47 29

Usa evalpara gerar dinamicamente a /. Usa +apenas para concatenação de cadeias, não adição.

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

EDIT: Usado em "\57"vez deString.fromCharCode(47)

Rubi ( 43 22 17)

Não apenas golfe, mas também elegância :)

p Rational gets,3

A saída será como (41/1). Se ele deve ser inteiro, devemos adicionar .to_iao resultado e, se mudarmos to_ipara to_f, também podemos obter saída para floats.

TI-Basic, 8 bytes

Vencedora? :)

int(mean({Ans,0,0

PS Arredonda para o infinito para números negativos (veja aqui o porquê). Para arredondar para zero, substitua int(por iPart(para não alterar os bytes.

Casos de teste

-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]))

Onde _ está o dividendo e é inserido como tal.

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

Nota: Não tenho certeza se o uso do intérprete interativo é permitido, mas de acordo com o OP: "A entrada pode estar em STDIN ou ARGV ou inserida de qualquer outra maneira"

Edit: Agora para python 3 (funciona em 2.x, mas imprime uma tupla). Trabalha com negativos.

C ++, 191

Com main e includes, seu 246, sem main e includes, é apenas 178. As novas linhas contam como 1 caractere. Trata todos os números como não assinados. Não recebo avisos por ter um retorno principal int sem sinal, portanto é um jogo justo.

Minha primeira submissão de codegolf.

#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;}

usa turnos para dividir o número por 4 repetidamente e calcula a soma (que converge para 1/3)

Pseudo-código:

// 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)).

Como um aparte, eu poderia eliminar o método principal nomeando d main e fazendo com que fosse necessário um caractere ** e usando o valor de retorno dos programas como saída. Ele retornará o número de argumentos da linha de comando dividido por três, arredondado para baixo. Isso leva seu comprimento aos 191 anunciados:

#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 caracteres

~3base);3base

PowerShell 57 ou 46

Em 57 caracteres, usando %como o operador foreach do PowerShell, não o módulo. Esta solução pode aceitar números inteiros positivos ou negativos.

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

Em 46 caracteres, se *for permitido como operador de repetição de cadeia, não multiplique. Esta opção requer números inteiros positivos como valores de entrada.

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

R

Eles funcionam apenas com números inteiros positivos:

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

Ou:

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

Ou:

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

Ou:

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

[[EDIT]] E um feio:

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

[[EDIT2]] Além disso, provavelmente o melhor - inspirado no código do matlab acima, de Elliot G:

length(seq(1,x,3))

SmileBASIC, 58 51 36 bytes (sem funções matemáticas!)

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

Explicação:

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

O programa move a camada de fundo suavemente por 3 quadros e, em seguida, obtém o ângulo após 1 quadro, quando percorre 1/3 da sua distância total.

Versão de divisão flutuante, 38 bytes:

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

Explicação:

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 chars

Funciona com o conjunto completo de números inteiros positivos e negativos

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

Primeiro, cria uma lista 1 ou (-1) '(dependendo do sinal da entrada) para cada terceiro número inteiro, de 0 até a entrada n.abs(n)para números negativos, inclusive.

por exemplo n=8 -> [0,3,6]

Em seguida, ele retorna a soma desta lista.

Clojure, 87; trabalha com negativos; com base em lazyseqs

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

Ungolfed:

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

Caderno prudente (21)

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