*, /, +, -,% ऑपरेटरों का उपयोग किए बिना एक संख्या को 3 से विभाजित करें

48

SO (स्पोइलर अलर्ट!) पर इस प्रश्न का हवाला देते हुए :

यह सवाल ओरेकल के एक साक्षात्कार में पूछा गया है।

आप *, /, +, -,%, ऑपरेटरों का उपयोग किए बिना किसी संख्या को 3 से कैसे विभाजित करेंगे?

संख्या पर हस्ताक्षर किए या अहस्ताक्षरित हो सकते हैं।

कार्य हल करने योग्य है, लेकिन देखें कि क्या आप सबसे छोटा कोड लिख सकते हैं।

नियम:

  • आवश्यक पूर्णांक विभाजन करें ( /3)
  • गैर-पाठ आधारित ऑपरेटरों का उपयोग न करें *, /, +, -, या %(या जैसे उनके समकक्ष, __div__या add())। यह इंक्रीमेंट और डिक्रिमेंटिंग ऑपरेटरों पर भी लागू होता है, जैसे i++या i--। स्ट्रिंग समवर्ती और स्वरूपण के लिए ऑपरेटरों का उपयोग ठीक है। विभिन्न संचालकों के लिए इन पात्रों का उपयोग करना, जैसे कि -ऋणात्मक संख्याओं के लिए अपर संचालक, या *C में एक सूचक का प्रतिनिधित्व करना ठीक है।
  • इनपुट मूल्य मनमाने ढंग से बड़ा हो सकता है (जो भी आपका सिस्टम संभाल सकता है), सकारात्मक और नकारात्मक दोनों
  • इनपुट STDIN या ARGV पर हो सकता है या किसी अन्य तरीके से दर्ज किया जा सकता है
  • सबसे छोटा कोड बनाएं जो आप ऊपर कर सकते हैं
code-golf  math  restricted-source  division 
— Gaffi
स्रोत
1
सकारात्मक होने पर परिणाम कैसे गोल होना चाहिए? कैसे नकारात्मक?
— dfeuer

जवाबों:

15

जे, ४५ ४४ १० चरस

".,&'r3'":

नकारात्मक के साथ काम करता है:

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

": - पाठ के रूप में प्रारूप

,&'r3'- r3अंत तक संलग्न करें

". - स्ट्रिंग निष्पादित करें, जैसे 15r3

— defhlt
स्रोत
1
यह काम करता है अगर आप ऐसा करेंगे 3 3 3 #: 9। ऐसा लगता है कि आपको यह जानने की जरूरत है कि आपकी टर्नरी संख्या कितनी लंबी होगी। _3]\i.किसी चीज के लिए एक संभावित शुरुआती बिंदु भी है, लेकिन मुझे नहीं पता कि यह आपके समाधान से छोटा होगा या नहीं। इसके साथ समस्या #_3]\i.यह है कि यह हमेशा नीचे की बजाय गोल होता है।
— गारेथ
1
शायद ##~3=_3#\i.11 पात्रों के लिए?
— गारेथ
1
वास्तव में, आप अपने आप को 10 वर्णों तक सिकोड़ सकते हैं ##~0 0 1$~।
— गारेथ
1
आप हुक का उपयोग करके इसे छोटा कर सकते हैं, 3#.}:(#:~$&3)लेकिन यह अभी भी लंबा है और यह नकारात्मक संख्या समस्या को ठीक नहीं करता है।
— गारेथ
1
हाँ, आप या तो उपयोग कर सकते हैं पावर समारोह ^: या एजेंडा @. एक के लिए ifया if...elseप्रतिस्थापन। इस स्थिति में आप @.एक शर्त के आधार पर एक या दूसरे का चयन करने के लिए एक '`' वर्ण (जे-स्पीक में एक गेरुंड) के साथ जुड़े दो क्रियाओं का उपयोग करने में सक्षम हो सकते हैं।
— गारेथ
56

सी, 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 MB / s की दर प्राप्त होती है। उत्पादन की दर यथोचित रूप से स्थिर मानी जा सकती है, इसलिए पूरा होने का समय लगभग 167503724710 B / (14.8 * 1048576 B / s) 4 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 लाइनों के बीच अनुकूलन नहीं करता है), मेमोरी ओवरहेड केवल कुछ किलोबाइट (कोड के अलावा, बिल्कुल) होना चाहिए।
— यांत्रिक घोंघा
स्रोत
22
यह हार्डकोडिंग का प्रतीक है। +++++++++++
— जो जेड।
4
यह कहा जा रहा है, मुझे यकीन है कि यदि आप उन्हें एक 160 जीबी स्रोत फ़ाइल देते हैं और उन्हें संकलन और परीक्षण करने के लिए कहते हैं, तो वे आपको ऐसे देखेंगे जैसे आप पागल थे।
— जो Z.
16
अगर मेरे बॉस ने मुझसे तीन के बिना एक विभाजन की गणना करने के लिए कहा - + / *% मुझे लगता है कि वह पागल है।
— मिकाइल मेयर
और फिर भी, के a[b]लिए एक सिंथेटिक चीनी है *(a + b), जो इसके अतिरिक्त है।
— कोनराड बोरोस्की
12
@ नाइकोलाबार्बुल्सको स्टैक एक्सचेंज के उत्तरों पर आकार प्रतिबंध है।
— समयटेक
38

रूबी २ 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

रूबी, ६० ४५

वैकल्पिक रूप से, आधार रूपांतरण का उपयोग करते हुए w / o:

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}
— defhlt
स्रोत
1
बिना आधार रूपांतरण के वैकल्पिक रूप से प्रतिबंधित /ऑपरेटर जहां Float::INFINITYबन गया है 1.0/0। रूबी 2.1 के साथ, एक को हटाने (0..1.0/0).step(3)में गोल्फ हो सकता 0.step(p,3)है /। बड़ी समस्या यह है कि नकारात्मक करने के लिए -rउपयोग करता -है। इसे बदलने के -rलिए 5 वर्णों की लागत आती है, जो घटाकर पूर्णांक संचालक के बिना 1 को घटाने के लिए Integer # pred को ~r.predगाली देता है ।
— kernigh
26

गणितज्ञ, 13 वर्ण

Mean@{#,0,0}&
— alephalpha
स्रोत
यह दुष्ट है: DI का अनुमान है कि आप &एक सादे चर को बचा सकते हैं और उसका उपयोग कर सकते हैं (अन्य यहाँ भी ऐसा करते हैं)।
— यवेस केलेट
3
@YvesKlett: मतलब स्वाभाविक रूप से दुष्ट है।
— गिटारपाइपर
18

जावास्क्रिप्ट, 56

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

nदोहराता है ,और के ,,,साथ की जगह की लंबाई की एक स्ट्रिंग बनाता है 1। फिर, यह स्ट्रिंग की परिणामी लंबाई को मापता है। (उम्मीद है कि एकता -की अनुमति है!)

— केसी चु
स्रोत
+1 लेकिन यह नकारात्मक मूल्यों के साथ काम नहीं करता है
— फ्रांसेस्को कसुला
उह, सवाल ... यह कैसे गिनता है? यह -निगेटिव ऑपरेटर का उपयोग करता है ।
— पैट्रिक रॉबर्ट्स
@Patrick मैं विनिर्देश ले लिया कोई घटाव मतलब करने के लिए - अगर आप चाहते हैं, तो आप बदल सकते हैं -~के साथparseInt()
— केसी चू
@CaseyChu द्वारा दिया गया मान -~prompt()एक से अधिक है parseInt(prompt())। निश्चित नहीं है कि आप इससे कैसे निपटेंगे।
— पैट्रिक रॉबर्ट्स
alert(Array(parseInt(prompt())).slice(1).join().replace(/,,,/g,1).length)
— केसी चू
16

अजगर, ४१ ३ 38

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

xrange बड़ी संख्या को संभालने में सक्षम होने के लिए लगता है (मुझे लगता है कि सीमा सी में एक लंबे समय के लिए समान है) लगभग तुरंत।

>>> x = -72
-24

>>> x = 9223372036854775806
3074457345618258602
— gRC
स्रोत
2
10/3बराबर 3, 4 नहीं।
— जोएल कोर्नेट
डूइंग print" -"[x<0]+लेन (रेंज (2, एब्स (x), 3)) `` इसे नीचे की ओर 39 दाढ़ी में शेव करेगा
— जोएल कॉर्नेट
Golfexchange की टिप्पणी स्वरूपण इसे गड़बड़ कर रही है। ऊपर मैंने बैकटिक्स का इस्तेमाल len()शॉर्टहैंड के रूप में संलग्न करने के लिए कियाrepr()
— जोएल कॉर्नेट
मैंने इसे अपडेट किया है। मैं उपयोग नहीं कर सकता range, क्योंकि यह वास्तव में सूची बनाएगा। xrangeसिर्फ दिखावा करता है, इसलिए यह समय / स्मृति को बर्बाद किए बिना बड़ी संख्या को संभालने में सक्षम है।
— grc
2
प्रिटेंड इट पायथन 3;) मुझे सिंगल चार स्लाइसिंग बीडब्ल्यूटी पसंद है।
— जोएल कॉर्नेट
11

हास्केल, 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( /=हास्केल में असमानता है) और जो करता है उसे पहले लौटाता है।

यदि कोई नकारात्मक संख्या नहीं है तो यह बहुत सरल हो जाता है:

25 27

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

बस nसूची के वें तत्व को वापस करता है [0,0,0,1,1,1,2, ...]।

— काउंटरक्लॉक को चालू करना बंद कर दिया
स्रोत
3
ऊ मैं उस दूसरे समाधान के बारे में कभी नहीं सोचा था। मैं अजगर में ऐसा कुछ करने में सक्षम हो सकता हूं
— अनुचर
8

सी #, 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);}}

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);
    }
}
— ड्रेक क्लेरिस
स्रोत
2
लगभग 5 साल बाद .. आप अंतरिक्ष से हटाकर 1 बाइट बचा सकते हैं string[] g, इसे string[]g
— मोड़कर
"गैर-पाठ-आधारित ऑपरेटरों *, /, +, -, या% (या उनके समकक्षों, जैसे div या add ​​()" का उपयोग न करते हुए उद्धृत करें - क्या आप एक समकक्ष का उपयोग नहीं कर रहे हैं .Add?
— जोनाथन फ्रीच
@JonathanFrech जो ऐड मेथड दो नंबरों पर काम नहीं करता है, यह केवल एक संग्रह के लिए एक मूल्य जोड़ता है
— इग्नोरेंस
7

पर्ल (26 22)

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

यह संस्करण (एब) पर्ल के रेगेक्स इंजन का उपयोग करता है। यह अंतिम कमांड लाइन तर्क के रूप में एक संख्या पढ़ता है ( pop) और 3इस लंबाई के s ( ) का एक स्ट्रिंग बनाता है "3" x $number। रेगेक्स प्रतिस्थापन संचालक ( s///, यहाँ पहेली के नियमों के कारण और एक gलोबाल ध्वज के साथ अलग-अलग परिसीमनकर्ताओं के साथ लिखा गया है ) तीन पात्रों को खाली स्ट्रिंग द्वारा प्रतिस्थापित करता है और प्रतिस्थापन की संख्या देता है, जो कि इनपुट संख्या पूर्णांक-तीन से विभाजित है। यह भी बिना लिखा जा सकता है 3, लेकिन उपरोक्त संस्करण मजेदार लग रहा है।

$ perl -E '$_=3x pop;say s|333||g' 42
14
— memowe
स्रोत
2
अरे @ मम्मो, अच्छा काम! आप कुछ और कार्य करके (4) बचा सकते हैं $_=3x pop;say s|333||g।
— डोम हेस्टिंग्स
2
जब इनपुट 0, 1, या 2 है, तो यह एक खाली स्ट्रिंग प्रिंट करता है। यदि इसे 0 प्रिंट करने की आवश्यकता है, तो इसे 3 और अक्षरों (25 कुल) की आवश्यकता है '$_=3x pop;say s|333||g||0:। 99999999 जैसी बड़ी संख्या के साथ धीमा, और नकारात्मक संख्या के साथ काम नहीं करता है।
— kernigh
1
-pकमांडलाइन पर उपयोग करें , और आप कर सकते हैं: $_=3x$_;$_=0|s|...||g0, 1, या 2 इनपुट की कवरेज सहित कुल 22 के लिए।
— Xcali
6

सी, 160 चार्ट

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

ध्यान दें:

  • गाली इसके अलावा लागू करने के लिए सरणी का उपयोग।
  • क्लैंग 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
— बच्चे-खरगोश
स्रोत
6

अजगर ४२

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

चूँकि हर समाधान यहाँ पोस्ट किया गया है कि Ive जाँच किए गए यहाँ दशमलव को काटता है जो मेरा समाधान है जो ऐसा करता है।

अजगर 50 51

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

चूँकि अजगर फर्श विभाजन करता है, यहाँ मेरा समाधान है कि लागू करता है।

इनपुट पूर्णांक चर x में है।

पायथन 2.7 में परीक्षण किया गया, लेकिन मुझे संदेह है कि यह 3 में भी काम करता है।

— मैट
स्रोत
+1 नकारात्मक मूल्य स्थिति के लिए दोनों विकल्पों की पेशकश के लिए। चूंकि पहले से ही बहुत सारे उत्तर हैं, इसलिए मैं एक या दूसरे विकल्प को बाहर करने के लिए युक्ति को समायोजित नहीं करूंगा, हालांकि मैं व्यक्तिगत रूप से सहमत हूं कि -3सही उत्तर है -10/3।
— गफ्फी
जो लोग अजगर में फर्श विभाजन की परवाह करते हैं: python-history.blogspot.com/2010/08/…
— मैट
आपके दूसरे समाधान में गुणा और घटाव के साथ क्या है?
— बूथ
@boothby दूसरा समाधान मंजिल विभाजन को लागू करता है। मैं नकारात्मक संख्याओं के लिए श्रेणी (0, abs (x), 3) और सकारात्मक संख्याओं के लिए श्रेणी (2, abs (x), 3) करना चाहता था। आदेश में यह करने के लिए कि मेरे पास रेंज (2 ... तब मैंने 2 घटाया है जब x ऋणात्मक है। x <0 x सत्य है जब x ऋणात्मक होता है, (True) * 2 == 2
— Matt
मैं फ़्लोर डिवीजन और डिसकंटिनल ट्रिमिंग के बीच अंतर नहीं समझ रहा हूँ। क्या यह नकारात्मक विभाजन के साथ है?
— जोएल कॉर्नेट
6

जावास्क्रिप्ट, 55

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

यदि कोई उपयोग नहीं कर सकता है -1, तो यहां एक संस्करण इसकी जगह ले रहा है ~0(धन्यवाद पीटर टेलर!)।

alert(parseInt((~~prompt()).toString(3).slice(0,~0),3))
— Inkbug
स्रोत
1
@ArtemIce एक ~बिटवाइज़र ऑपरेटर है जो ऑपरेटर के बिट्स को निष्क्रिय करता है (पहले इसे एक संख्या में परिवर्तित करता है)। यह एक स्ट्रिंग को संख्या में बदलने का सबसे छोटा तरीका है (जहाँ तक मुझे पता है)।
— 10
1
मुझे लगता है कि स्ट्रिंग पार्सिंग / रूपांतरण का उपयोग करना धोखा दे रहा है, क्योंकि इसकी क) बिटवाइज ऑपरेशंस की तुलना में एक बहुत ही जटिल और महंगी प्रक्रिया है, बी) निषिद्ध ऑपरेटरों का आंतरिक रूप से उपयोग करता है, और सी) एक होमोलॉइड समाधान की तुलना में वायाएयर अधिक वर्णों को ले जाएगा। इस तरह की तरह कि जब आप क्विकॉर्ट को लागू करने के लिए कहते हैं, तो लोग आपके द्वारा बनाए गए तरीके का उपयोग करने पर कैसे क्रोधी हो जाते हैं।
— खोदा
1
@ इसके अलावा, ~~एक पूर्णांक में कनवर्ट करता है, जैसा कि विरोध किया गया है +।
— 4
1
@ यह कोडगोल्फ है, इस प्रकार यह कार्य के बारे में निर्दिष्ट होने तक दक्षता के बारे में नहीं है।
— डिफाल्ट
3
विभिन्न ठिकानों का लाभ उठाने के लिए +1। यह मेरी पसंदीदा जावास्क्रिप्ट गोल्फ तकनीकों में से एक है।
— DocMax
6

C 83 वर्ण

विभाजित करने की संख्या को main()स्टड के माध्यम से पारित किया जाता है, और इसे (सीएमडी में% 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;}

एकल निगेट तो है की अनुमति दी: (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;}

संपादित करें: बदसूरत मुझे बताया कि - ~ एक वेतन वृद्धि है ...

83 अक्षर अगर एकतरफा नकार की अनुमति है: डी

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;}
— Kaslai
स्रोत
यदि अकारण उपेक्षा की अनुमति है, x+3है -~-~-~x।
— रात 11:12 पर बदसूरत
उसके लिये आपका धन्यवाद। मुझे नहीं पता कि मेरे साथ ऐसा क्यों हुआ। मुझे लगता है कि मुझे नहीं पता था कि आप यूनियनों को ढेर कर सकते हैं इसलिए बहुत खुशी है।
— कसलाई 7
5

सी, 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 चार्ट को बचाया।
— बच्चे-खरगोश
स्रोत
1
अच्छी तरह से किया। मैंने अपनी पूरी कोशिश की कि मैं थोड़ा ट्विडलिंग करूं और 239 पर पहुंच जाऊं। मैं सिर्फ अपना सिर आपके आस-पास नहीं पहुंचा सकता A, मेरा काम बस नंबर I में बिट की जांच करता है। क्या सी मानक प्रकार की घोषणाओं को छोड़ने की अनुमति देता है या वह कुछ संकलक चीज है?
— शियोना
1
यदि अनिर्दिष्ट हो तो C मान जाएगा।
— खोदा
5

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

यह उसी आधार रूपांतरण चाल का उपयोग करता है जैसे आर्टेम आइस का उत्तर ।

— जॉन गौथियर
स्रोत
5

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. जब तक संख्या ऊपर है तब तक इसे दोहराया जाता है। iगिना जाता है कि यह कितनी बार किया गया है ( &i[1]= i+1)।

— ugoren
स्रोत
कोड को समझने की कोशिश कर रहा है, किसी ने कुछ रोशनी? धन्यवाद
— कांग हुयी
@Chui, जोड़ा स्पष्टीकरण।
— बदसूरत
@ जहाँ तक मैं समझता हूँ, प्रिंट ("% d") को हेक्स में रखे मेमोरी एड्रेस पॉइंटर को प्रिंट नहीं करना चाहिए? क्यों यह एक पूर्णांक को प्रिंट कर रहा है? या चार * मैं डिफ़ॉल्ट रूप से स्मृति पते 0 को इंगित करने के लिए आरंभीकृत किया गया था? धन्यवाद
— कांग हुआ
5

जावा 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 केविन क्रूज़सेन।

— vectorized
स्रोत
मैं जानता हूँ कि यह एक से अधिक दो साल पहले हो गया है, लेकिन आप गोल्फ में कुछ हिस्सों कर सकते हैं: &&करने के लिए &, और 2x Integerकरने के लिए Long। (इसके अलावा, आप ~2सिर्फ के बजाय क्यों उपयोग करते हैं -3? वे एक ही बाइट-गिनती हैं।)
— केविन क्रूज़सेन
1
इतने लंबे समय के बाद मेरी पहली पोस्ट को संपादित करने के लिए @KevinCruijssen इतना उदासीन। यह भी निश्चित नहीं था कि मुझे क्यों लगा कि ~ 2 तब बेहतर था।
— वेक्टर
2
@KevinCruijssen अच्छी तरह से, चुनौती कहती है कि आपको उपयोग करने की अनुमति नहीं है -, लेकिन मुझे नहीं पता कि क्या यह एकाकी नकार के लिए मायने रखता है।
— बजे
@FlipTack आह तुम पूरी तरह से सही हो। उस मामले में भूल जाओ मैंने कभी कहा था। :)
— केविन क्रूज़सेन
4

पायथन 2.6 ( 29 ) ( 71 ) ( 57 ) ( 52 ) (43)

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


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

संपादित करें - बस एहसास हुआ कि हमें नकारात्मक पूर्णांक भी संभालना है। बाद में ठीक कर देंगे

एडिट 2 - फिक्स्ड

Edit3 - जोएल कॉर्नेट की सलाह का पालन करते हुए 5 चार्ट सहेजे गए

Edit4 - चूँकि इनपुट आवश्यक रूप से STDIN या ARGV से नहीं होना चाहिए, इसलिए अध्यादेश का कोई भी इनपुट नहीं लेने से 9 वर्णों को बचाया जा सकता है

— elssar
स्रोत
आगे बढ़ोabs()
— 7
करने के लिए कमprint z if x==abs(x) else -z
— जोएल कॉर्नेट
बेहतर अभी तक,print (z,-z)[x<0]
— जोएल कॉर्नेट
@ArtemIce धन्यवाद, केवल एहसास हुआ कि मैं एक और उत्तर ऊपर पढ़ने के बाद उपयोग कर सकता हूं।
— एलसर
@JoelCornett humm, उस बारे में नहीं जानते थे, धन्यवाद
— elssar
4

जावास्क्रिप्ट, 47 29

evalगतिशील रूप से उत्पन्न करने के लिए उपयोग करता है a /। +केवल स्ट्रिंग संघनन के लिए उपयोग करता है , इसके अलावा नहीं।

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

EDIT: के "\57"बजाय उपयोग किया जाता हैString.fromCharCode(47)

— पीटर ओल्सन
स्रोत
-1 के लिए alert(eval(prompt()+"\573"))?
— शायरु असकोतो
4

रूबी ( 43 22 17)

न केवल गोल्फ, बल्कि लालित्य भी :)

p Rational gets,3

आउटपुट जैसा होगा (41/1)। यदि यह पूर्णांक होना चाहिए, तो हमें .to_iपरिणाम में जोड़ना होगा , और यदि हम बदलते to_iहैं to_fतो हम फ़्लोट के लिए भी आउटपुट प्राप्त कर सकते हैं।

— Hauleth
स्रोत
1
rationalरूबी 1.9.3 पर आवश्यकता रेखा के बिना काम करता है । कोष्ठक को छोड़ना एक और चार को बचाता है ।
— स्टेन्सलैग
4

टीआई-बेसिक, 8 बाइट्स

विजेता? :)

int(mean({Ans,0,0

PS नकारात्मक संख्याओं के लिए अनंत की ओर बढ़ते हैं ( यहाँ देखें क्यों)। इसके बजाय शून्य पर गोल करने int(के iPart(लिए, बिना बाइट परिवर्तन के साथ बदलें।

परीक्षण के मामलों

-4:prgmDIVIDE
              -2
11:prgmDIVIDE
               3
109:prgmDIVIDE
              36
— Timtech
स्रोत
3

पायथन 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 पर हो सकता है या किसी अन्य तरीके से प्रवेश कर सकता है"

संपादित करें: अब अजगर 3 के लिए (2.x में काम करता है, लेकिन टपल प्रिंट करता है)। नकारात्मक के साथ काम करता है।

— जोएल कॉर्नेट
स्रोत
अजगर 3 में भी काम करता है?
— मेकैनिकल घोंघा
सबस्क्रिप्ट करने योग्य नहीं है; होना ही __len__काफी है।
— मैकेनिकल जेल
len(range(100,1000))900लिनक्स में 3.2.3 में देता है।
— मैकेनिकल जेल
यह ऋणात्मक संख्याओं के लिए काम नहीं करता है। और len(xrange(0,_,3))वैसे भी कम और बड़े पैमाने पर तेज है।
— जीआरसी
@ मेकेनिसेल: पॉइंट लिया गया। मैं मान गया। यह 3 पर काम करता है।
— जोएल कॉर्नेट
3

सी ++, 191

मुख्य और शामिल है, इसका 246, मुख्य के बिना और शामिल है, यह केवल 178 है। न्यूलाइन्स 1 चरित्र के रूप में गिना जाता है। सभी नंबरों को अहस्ताक्षरित मानता है। मुझे मुख्य रूप से एक अहस्ताक्षरित इंट के लिए चेतावनी नहीं मिलती है, इसलिए यह उचित खेल है।

मेरी पहली बार कोडगॉल्फ सबमिशन।

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

संख्या को बार-बार विभाजित करने के लिए पाली का उपयोग करता है, और योग की गणना करता है (जो 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)).

एक तरफ के रूप में, मैं डी मुख्य नामकरण करके मुख्य विधि को समाप्त कर सकता है और इसे एक च ** ले सकता है और आउटपुट के रूप में प्रोग्राम रिटर्न मान का उपयोग कर सकता है। यह कमांड लाइन तर्कों की संख्या को तीन से विभाजित करेगा, नीचे राउंडेड होगा। यह विज्ञापित 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;}
— WUG
स्रोत
3

गोल्फस्क्रिप्ट - 13 वर्ण

~3base);3base
— gnibbler
स्रोत
नकारात्मक इनपुट को संभालने के लिए प्रतीत नहीं होता है
— रेस
1
@res s/seem to //:(। मुझे इसके बारे में सोचना होगा
— gnibbler
3

PowerShell 57 या 46

%PowerShell foreach ऑपरेटर के रूप में उपयोग करने वाले 57 अक्षरों में , modulo नहीं। यह समाधान सकारात्मक या नकारात्मक पूर्णांक को स्वीकार कर सकता है।

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

46 वर्णों में यदि *स्ट्रिंग पुनरावृत्ति ऑपरेटर के रूप में अनुमति दी गई है, तो गुणा नहीं। इस विकल्प को इनपुट मान के रूप में सकारात्मक पूर्णांक की आवश्यकता होती है।

("1"*(Read-Host)-replace111,0-replace1).Length
— जोसेफ अलकोर्न
स्रोत
यदि आप कभी वापस आते हैं, तो मैंने एक बग फिक्स पोस्ट किया। यदि आप चाहते हैं कि मैं खदान को हटा दूं और आप में बदलाव को शामिल करूं, तो मुझे बताएं।
— विस्कह
3

आर

ये केवल सकारात्मक पूर्णांक के साथ काम करते हैं:

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]] प्लस शायद सबसे अच्छा एक - इलियट जी द्वारा ऊपर दिए गए मैटलैब कोड से प्रेरित है:

length(seq(1,x,3))
— lebatsnok
स्रोत
मैं आपके EDIT2 में उसी विचार को लागू करना चाहता था लेकिन यह नकारात्मक संख्याओं के लिए काम नहीं करता है:wrong sign in 'by' argument
— आंद्रेï कोस्टीर्का
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
— 12Me21
स्रोत
3

हास्केल 41 39 वर्ण

सकारात्मक और नकारात्मक पूर्णांक के पूर्ण सेट के साथ काम करता है

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

पहले प्रत्येक तीसरे पूर्णांक के लिए इनपुट तक 1 (या (-1) इनपुट के आधार पर) एक सूची बनाता है n।abs(n)नकारात्मक संख्या के लिए समावेशी।

जैसे n=8 -> [0,3,6]

यह तब इस सूची का योग लौटाता है।

— चार्ल क्रूगर
स्रोत
नकारात्मक संख्याओं पर काम नहीं करता है (-3/3 -1 -1 नहीं 1)।
— कॉर्मैक
अच्छा लगा कि आपने इसे नकारात्मक संख्याओं पर काम किया लेकिन आप विनिर्देश का उपयोग नहीं कर सकते / कर सकते हैं।
— कॉर्मैक
हे भगवान, आपने मुझे दो बार प्राप्त किया। सभी तय;)
— चार्ल क्रूगर
अच्छा! Btw आप fn = sum [39 $ 1: [- 2 | n <0] | i <- [3,6..abs n]] के साथ 39 char प्राप्त कर सकते हैं
— Cormac
2

क्लोजर, 87; नकारात्मक के साथ काम करता है; आलसी पर आधारित है

(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))))
— defhlt
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.