Цитуючи це запитання на 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

Ось мій варіант вирішення проблеми. Я визнаю, що навряд чи виграє змагання з гольфу з суворим кодом, але він не використовує жодних хитрощів для опосередкованого виклику вбудованої функціональності підрозділу, він написаний на портативному С (як запитували оригінальні запитання щодо переповнення стека), він прекрасно працює для негативних чисел, і код є виключно чітким і явним.

Моя програма - це вихід із наступного сценарію:

#!/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 Мб / с. Швидкість виходу можна вважати приблизно постійною, тому час роботи до завершення повинен становити приблизно 167503724710 Б / (14,8 * 1048576 Б / с) ≈ 10794 с.
• Час компіляції - компілятор TCC претендує на компіляцію коду С зі швидкістю 29,6 Мб / с , що складає час компіляції 167503724710 Б / (29,6 * 1048576 Б / с) ≈ 5397 с. (Звичайно, це може працювати в конвеєрі зі сценарієм.)
• Розмір компільованого коду - я спробував оцінити його за допомогою ./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}

Математика, 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) майже миттєво.

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

просто повертає nth елемент списку [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) і будує рядок 3s такої довжини ( "3" x $number). Оператор заміни регулярних виразів ( s///тут написано різними роздільниками через правила головоломки та з gлобальним прапором) підміняє три символи порожнім рядком і повертає число підстановок, яке є вхідним числом на ціле число, поділене на три. Це навіть можна було б написати без 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, інші компілятори можуть barf.

Тестування:

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

Пітон 42

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

Оскільки кожне рішення, розміщене тут, що я перевіряв усікання десяткових знаків, - це моє рішення, яке це робить.

Пітон 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(спасибі Пітер Тейлор!).

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

C 83 символів

Число для поділу передається через stdin, і воно повертає його як код виходу з main()(% ERRORLEVEL% у CMD). Цей код зловживає деякими версіями 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;}

Якщо унарний NEGATE 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;}

EDIT: 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

Зміни:

• збережено 10 знаків переміщенням додавання (A) для видалення локальних змінних.

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

Для цього використовується такий же трюк базового перетворення, як і відповідь Артема Айда .

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

Java 86 79

Припустимо, ціле число знаходиться у:

Перетворює на рядок у базі 3, видаляє останній символ (правий зсув ">>" у базі 3), а потім перетворює назад у ціле число.

Працює для від’ємних чисел.

Якщо число, у, <3 або> -3, то воно дає 0.

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

Перший раз розміщення на коді гольфу. =) Тому поки що не можу коментувати.

Thx Кевін Круїссен для порад.

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 - Збережено 5 символів, дотримуючись порад Джоела Корнетта

Edit4 - Оскільки введення не повинно бути обов'язково з STDIN або ARGV, збережено 9 символів, не беручи жодного вводу від stdin

Javascript, 47 29

Використовує evalдля динамічного генерування а /. Використовується +лише для з'єднання рядків, а не для додавання.

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

EDIT: Використовується "\57"замістьString.fromCharCode(47)

Рубі ( 43 22 17)

Не тільки гольф, але й елегантність :)

p Rational gets,3

Вихід буде подібний (41/1). Якщо це повинно бути цілим числом, ми повинні додати .to_iрезультат, і якщо ми змінимося to_iна to_fто, ми також зможемо отримати вихід для плавців.

TI-Basic, 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

Примітка: Не впевнений, чи дозволено використання інтерактивного перекладача, але згідно з ОП: "Введення може бути на STDIN або ARGV або введене будь-яким іншим способом"

Редагувати: тепер для python 3 (працює в 2.x, але друкує кортеж). Працює з негативами.

С ++, 191

З головним і включає, його 246, без основного і включає, це всього 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 і змусивши його взяти знак ** і використовувати програми повернення значення як вихід. Він поверне кількість аргументів командного рядка, розділених на три, округлених вниз. Це наближає свою довжину до рекламованого 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;}

Гольфскрипт - 13 символів

~3base);3base

PowerShell 57 або 46

В 57 символів, які використовуються %як оператор foreach PowerShell, а не модуль. Це рішення може приймати натуральні чи від'ємні цілі числа.

(-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]] Плюс, мабуть, найкращий - натхненний вище кодом матлаба Елліотом G:

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 кадру, коли він пройшов 1/3 своєї загальної відстані.

Версія з поплавковим поділом, 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]]

Спочатку створюється список 1 або (-1) '(залежно від знаку введення) для кожного третього цілого числа від 0 до моменту введення n. abs(n)для від’ємних чисел включно.

напр n=8 -> [0,3,6]

Потім він повертає суму цього списку.

Clojure, 87; працює з негативами; на основі лениць

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