ऊपर जा बिट्स!

26

पूर्णांक N को देखते हुए निम्नलिखित चरण हैं: (उदाहरण के रूप में 9 का उपयोग करते हुए)।

  1. इनपुट N. ( 9) प्राप्त करें
  2. Base10 से base2 में N कन्वर्ट करें। ( 1001)
  3. हर 1 से बढ़ाएँ 1. ( 2112)
  4. आधार 3 के रूप में परिणाम का इलाज करें और इसे वापस आधार 10 में परिवर्तित करें। ( 68)
  5. परिणाम वापस करें / आउटपुट करें।

इनपुट

किसी भी उचित संख्या प्रारूप में प्राप्त किया जा सकता है।
आपको केवल उन मामलों को संभालना होगा जहां N> 0।

उत्पादन

या तो एक संख्या या स्ट्रिंग के रूप में लौटें, या प्रिंट करें stdout।

नियम

  • यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड।
  • डिफ़ॉल्ट कमियां निषिद्ध हैं।

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

1 -> 2
2 -> 7
5 -> 23
9 -> 68
10 -> 70
20 -> 211
1235 -> 150623
93825 -> 114252161
code-golf  number  base-conversion 
— इयान एच।
स्रोत

जवाबों:

15

पायथन 2 , 31 बाइट्स

f=lambda n:n and 3*f(n/2)+n%2+1

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
3
क्या आप बता सकते हैं कि यह कैसे काम करता है?
+n%2+1सही बाइनरी बिट प्लस 1 को रिटर्न वैल्यू में जोड़ता है, n/2राइट nबाय -शिफ्ट्स 1 बायनरी 3*f(n/2)बिट्स में, n andn
— रीक्रिएटली
11

जावास्क्रिप्ट (Node.js) , 23 बाइट्स

f=x=>x&&x%2+1+3*f(x>>1)

इसे ऑनलाइन आज़माएं!

— l4m2
स्रोत
x>>1जैसा है वैसा ही x/2नहीं है?
— mbomb007
@ mbomb007 मैंने अभी तक यही सोचा था और सुझाव दिया था, लेकिन जाहिरा तौर पर यह Infinityजेएस में हो जाता है .. इसे ऑनलाइन प्रयास करें। (आप जवाब के लिए एक TIO- लिंक जोड़ना चाहते हो सकता है, I4m2 )
— केविन क्रूज़सेन
2
@ mbomb007 नंबर 1>>1=0जबकि1/2=0.5
— l4m2
4
@ mbomb007 ... पायथन?
— user202729
2
हाँ। अजगर जवाब को देखो। यही कारण n/2है कि एक में काम करता है, और यही कारण है कि मैंने इसे यहां सुझाया है।
— mbomb007
9

जावा (JDK 10) , 44 बाइट्स

long n(long x){return x<1?0:x%2+1+3*n(x/2);}

इसे ऑनलाइन आज़माएं!

— user202729
स्रोत
1
शायद -~मदद मिलेगी?
— user202729
2
नहीं, पूर्ववर्ती नियम।
— user202729
आपसे एक ही सवाल: क्यों long? :) और यहाँ मुझे लगा कि मेरा अनुक्रम दृष्टिकोण स्मार्ट था .. आपने इसे 5 मिनट से भी कम समय में पार्क से बाहर निकाल दिया ..>>: '(
— केविन क्रूज़सेन
@KevinCruijssen आपके साथ निष्पक्ष होना ...
— user202729
6

जेली , 4 बाइट्स

B‘ḅ3

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत
बाइनरी, इंक्रीमेंट, टू-बेस, 3. यह वास्तव में कहा जाने वाला है।
— एडम
2
@ एडम तकनीकी तौर पर यह है कि से -base, लेकिन हाँ, यह सबसे में मामूली बात है, अगर सभी नहीं, भाषाओं गोल्फ।
— आउटगोल्फर
6

जे , 7 बाइट्स

3#.1+#:

इसे ऑनलाइन आज़माएं!

-4 बाइट्स के लिए धन्यवाद गैलेन इवानोव! मैं वास्तव में अपने जम्मू गोल्फ कौशल में सुधार की जरूरत है ...

— user202729
स्रोत
1
7 बाइट्स: 3#.1+#: TIO
— गैलेन इवानोव
टेम्पलेट के लिए भी धन्यवाद, मुझे इसके बारे में जानने के लिए कुछ चाहिए : 0।
— user202729 14
टेम्पलेट मेरा नहीं है, मैं भूल गया कि इसका लेखक कौन है।
— गैलेन इवानोव
2
वह मैं होगा :)
— कॉनर ओ'ब्रायन
6

आर , 55 43 बाइट्स

function(n)(n%/%2^(x=0:log2(n))%%2+1)%*%3^x

इसे ऑनलाइन आज़माएं!

R, वेतन वृद्धि में मानक आधार रूपांतरण चाल का उपयोग करता है, और फिर 3एक पूर्णांक में वापस परिवर्तित करने की शक्तियों के साथ एक डॉट उत्पाद का उपयोग करता है ।

12 बाइट छोड़ने के लिए @ user2390246 धन्यवाद !

— ग्यूसेप
स्रोत
क्योंकि बाइनरी में रूपांतरण अंतिम आउटपुट नहीं है, अंकों का क्रम मायने नहीं रखता है। इसलिए फर्श के बजाय (लॉग (n)): 0 आप 0 कर सकते हैं: log (n) और कुछ बाइट्स बचाएं: 43 बाइट्स
— user2390246
@ user2390246 बेशक, धन्यवाद।
— Giuseppe
6

जावा 10, 81 52 बाइट्स (आधार रूपांतरण)

n->n.toString(n,2).chars().reduce(0,(r,c)->r*3+c-47)

इसे ऑनलाइन आज़माएं।

-29 बाइट्स @ हैल्गर को धन्यवाद ।

स्पष्टीकरण:

n->{                         // Method with Long as both parameter and return-type
  n.toString(n,2)            //  Convert the input to a Base-2 String
  .chars().reduce(0,(r,c)->  //  Loop over its digits as bytes
    r*3+c-47)                //  Multiply the current result by 3, and add the digit + 1
                             //  (which is equal to increasing each digit by 1,
                             //  and then converting from Base-3 to Base-10)

जावा 10, 171 167 151 150 149 बाइट्स (अनुक्रम)

n->{int t=31-n.numberOfLeadingZeros(n);return a(t+1)+b(n-(1<<t));};int a(int n){return--n<1?n+2:3*a(n)+1;}int b(int n){return n<1?0:n+3*b(n/=2)+n*2;}

-16 बाइट्स @ Musicman523 , को बदलने के (int)Math.pow(2,t)लिए धन्यवाद (1<<t)।
-1 बाइट धन्यवाद @Holger , बदल रहा है (int)(Math.log(n)/Math.log(2))करने के लिए 31-n.numberOfLeadingZeros(n)।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

n->{                         // Method with Integer as both parameter and return-type
  int t=31-n.numberOfLeadingZeros(n);
                             //  2_log(n)
  return a(t+1)              //  Return A060816(2_log(n)+1)
         +b(n-(1<<t));}      //   + A005836(n-2^2_log(n))

// A060816: a(n) = 3*a(n-1) + 1; a(0)=1, a(1)=2
int a(int n){return--n<1?n+2:3*a(n)+1;}

// A005836: a(n+1) = 3*a(floor(n/2)) + n - 2*floor(n/2).
int b(int n){return n<1?0:n+3*b(n/=2)+n*2;}

जब हम अनुक्रम को देखते हैं:

2,  7,8,  22,23,25,26,  67,68,70,71,76,77,79,80,  202,203,205,206,211,212,214,215,229,230,232,233,238,239,241,242, ...

हम कई बाद देख सकते हैं:

A053645(n):
0,  0,1,  0,1,2,3,  0,1,2,3,4,5,6,7,  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,  ...

A060816(A053645(n)):
2,  7,7,  22,22,22,22,  67,67,67,67,67,67,67,67,  202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,  ...

A005836(A053645(n)+1)
0,  0,1,  0,1,3,4,  0,1,3,4,9,10,12,13,  0,1,3,4,9,10,12,13,27,28,30,31,36,37,39,40,  ...

इसलिए पूछा जा रहा अनुक्रम है:

A060816(A053645(n)) + A005836(A053645(n)+1)

मैं पैटर्न खोजने पर चूसता हूं, इसलिए मुझे ऊपर जो मिला है, उस पर मुझे गर्व है .. कहा जा रहा है कि, @ user202729 ने कुछ ही मिनटों में जावा में एक बेहतर और छोटा दृष्टिकोण पाया ..: '(

— केविन क्रूज़सेन
स्रोत
रे n.toString(n,2).getBytes()... मुझे लगता है कि मैनुअल रूपांतरण कम हो सकता है।
— user202729
1
BTW क्यों longऔर क्या नहीं int?
— user202729 12
1
मुझे लगता है कि अनुक्रम संस्करण में आप के (int)Math.pow(2,t)लिए बदल सकते हैं 1<<t... और फिर उस अभिव्यक्ति को इनलाइन करें और चर को छोड़ दें i ( 152 बाइट्स )
— musicman523
1
वास्तविक जीवन में, मैं 31-Integer.numberOfLeadingZeros(n)इसके बजाय उपयोग करूंगा (int)(Math.log(n)/Math.log(2)), लेकिन यह कम नहीं है। जब तक आप import staticहेडर में उपयोग नहीं करते हैं , जो नियमों को बहुत दूर तक खींच सकता है।
— होल्गर
1
मैंने बस आपके पहले वेरिएंट के लूप को स्ट्रीम सॉल्यूशन में बदलने की कोशिश की, सफलता के साथ:n -> n.toString(n,2).chars().reduce(0,(r,c)->r*3+c-47)
— Holger
3

अटैची , 19 बाइट्स

FromBase&3@1&`+@Bin

इसे ऑनलाइन आज़माएं!

यह तीन कार्यों की एक रचना है:

  • FromBase&3
  • 1&`+
  • Bin

यह पहले बाइनरी ( Bin) में परिवर्तित होता है , इसे बढ़ाता है ( 1&`+), फिर टर्नरी ( FromBase&3) में परिवर्तित होता है ।

वैकल्पिक

गैर-पॉइंटफ्री, 21 बाइट्स: {FromBase[Bin!_+1,3]}

बिना निर्माण के, 57 बाइट्स: Sum@{_*3^(#_-Iota!_-1)}@{If[_>0,$[_/2|Floor]'(1+_%2),[]]}

— कोनोर ओ ब्रायन
स्रोत
3

रेटिना 0.8.2 , 36 बाइट्स

.+
$*
+`^(1+)\1
$1;1
^
1
+`1;
;111
1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$*

दशमलव से भिन्न में परिवर्तित करें।

+`^(1+)\1
$1;1

बार-बार 2 से divmod, और modulo के परिणाम में 1 जोड़ें।

^
1

पहले अंक में 1 भी जोड़ें।

+`1;
;111

यूनिरी-एनकोडेड बेस 3 से यूरीरी में कनवर्ट करें।

1

दशमलव में परिवर्तित करें।

— नील
स्रोत
3

जाप , 6 बाइट्स

¤cÄ n3
¤      // Convert the input to a base-2 string,
 c     // then map over it as charcodes.
  Ä    // For each item, add one to its charcode
       // and when that's done,
    n3 // parse the string as a base 3 number.

एक नंबर के रूप में इनपुट लेता है, एक नंबर आउटपुट करता है।

इसे ऑनलाइन आज़माएं!

— लीख
स्रोत
लानत है! मैंने ऐसा क्यों नहीं सोचा? अच्छी तरह से किया।
— झबरा
3

MATL , 12 7 6 बाइट्स

BQ3_ZA

इसे ऑनलाइन आज़माएं!

सहेजी गयी 5 ग्यूसेप करने के लिए धन्यवाद और लुइस Mendo के लिए एक और एक धन्यवाद बाइट्स।

पुराना 7 बाइट उत्तर: 

YBQc3ZA

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

YB        % Convert to binary string
  Q       % Increment each element
   c      % Convert ASCII values to characters
    3     % Push 3
     ZA   % Convert from base 3 to decimal.

12 बाइट्स के लिए पुराना एक:

BQtz:q3w^!Y*

इसे ऑनलाइन आज़माएं!

ओह मेरी, वह गन्दा था ... तो यह है: `BQ3GBn: q ^! Y *।

स्पष्टीकरण:

               % Implicit input
B              % Convert to binary vector
 Q             % Increment all numbers
  t            % Duplicate
   z           % Number of element in vector
    :          % Range from 1 to that number
     q         % Decrement to get the range from 0 instead of 1
      3        % Push 3
       w       % Swap order of stack
        ^      % Raise 3 to the power of 0, 1, ...
         !     % Transpose
          Y*   % Matrix multiplication
               % Implicit output
— स्टीवी ग्रिफिन
स्रोत
3

सी # (विजुअल सी # कंपाइलर) , 128 बाइट्स

using System;using System.Linq;i=>{int z=0;return Convert.ToString(i,2).Reverse().Select(a=>(a-47)*(int)Math.Pow(3,z++)).Sum();}

इसे ऑनलाइन आज़माएं!

मैं गिनती कर रहा हूं Systemक्योंकि मैं उपयोग करता हूं Convertऔर Math।

— Hyarus
स्रोत
चयन आपको सूचकांक को वैकल्पिक पैरामीटर के रूप में देता है। इसलिए आप अपने zवैरिएबल से छुटकारा पा सकते हैं । इसके अलावा अभिव्यक्ति शरीर में आप से छुटकारा मिल सकता है {, }और returnबयान। तो कुछ इस तरहn=>Convert.ToString(n,2).Reverse().Select((x,i)=>(x-47)*Math.Pow(3,i)).Sum();
— NtFreX
2

सी, 32 27 बाइट्स

n(x){x=x?x%2+1+3*n(x/2):0;}

User202729 के जावा उत्तर के आधार पर । इसे यहाँ ऑनलाइन आज़माएँ । 5 बाइट गोल्फिंग के लिए केविन क्रूजसेन को धन्यवाद ।

Ungolfed संस्करण:

n(x) { // recursive function; both argument and return type are implicitly int
    x = // implicit return
    x ? x % 2 + 1 + 3*n(x/2) // if x != 0 return x % 2 + 1 + 3*n(x/2) (recursive call)
    : 0; // else return 0
}
— OOBalance
स्रोत
आप 5 बाइट्स के returnसाथ बदलकर x=और टर्नरी को उलट कर बचा सकते हैं , इसलिए !अब जरूरी नहीं है:n(x){x=x?x%2+1+3*n(x/2):0;}
— केविन क्रूज़सेन
@KevinCruijssen अच्छा लगा। धन्यवाद!
— OOBalance 13
2

संचार टूलबॉक्स के साथ ऑक्टेव , 33 32 बाइट्स

@(x)(de2bi(x)+1)*3.^(0:log2(x))'

इसे ऑनलाइन आज़माएं!

एक बाइनरी वेक्टर का उपयोग करके इनपुट को परिवर्तित करता है de2bi, और सभी संख्याओं को बढ़ाता है। क्या उपयुक्त शक्तियों को उठाए गए 3 के ऊर्ध्वाधर वेक्टर के साथ मैट्रिक्स गुणन होता है : 1, 3, 9, ...इस प्रकार एक स्पष्ट कॉल के बिना योग प्राप्त करना sum।

— स्टीवी ग्रिफिन
स्रोत
जबकि यह बेहद चालाक है, आप इसे 32 बाइट्स के लिए भी कर सकते हैं: इसे ऑनलाइन आज़माएं!
— Sanchises
और MATLAB के साथ आप @(x)base2dec(de2bi(x)+49,3)27 के लिए भी कर सकते हैं (एक दुर्लभ अवसर जहां MATLAB ऑक्टेव से अधिक उदार है)
— Sanchises
2

PHP, 84 64 बाइट्स

इसे ऑनलाइन आज़माएं !!

मूल कोड

function f($n){$b=decbin($n);echo base_convert($b+str_repeat('1',strlen($b)),3,10);}

इसे ऑनलाइन आज़माएं !!

क्रिस्टोफ़ के लिए धन्यवाद , अगर php -R के साथ कम बाइट्स

function f($n){echo base_convert(strtr(decbin($n),10,21),3,10);}

व्याख्या

function f($n){
$b=decbin($n);                    #Convert the iteger to base 2
echo base_convert(                  #base conversion PHP function
    $b+str_repeat('1',strlen($b)),  #It adds to our base 2 number
    3,                              #a number of the same digits length
    10);                            #with purely '1's
}
— फ्रांसिस्को हैन
स्रोत
यहाँ है जब मैं देख रहा हूँ कि मेरे पास प्रोग्रामिंग पर जाने के लिए एक अलग रास्ता है .... के अस्तित्व का कोई पता नहीं थाstrtr
— फ्रांसिस्को हैन
1
करेंगे !!, क्षमा करें<?="Will do!!"
— फ्रांसिस्को हैन
2

व्हॉट्सएप , 117 बाइट्स

[S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][N
S S S N
_Create_Label_OUTER_LOOP][S N
S _Duplicate][S S S T   S N
_Push_2][T  S T T   _Modulo][S S S T    N
_Push_1][T  S S S _Add][S N
T   _Swap][S S S T  S N
_Push_2][T  S T S _Integer_division][S N
S _Duplicate][N
T   S N
_If_0_jump_to_Label_INNER_LOOP][N
S N
S N
_Jump_to_Label_OUTER_LOOP][N
S S N
_Create_Label_INNER_LOOP][S S S T   T   N
_Push_3][T  S S N
_Multiply][T    S S S _Add][S N
T   _Swap][S N
S _Duplicate][N
T   S T N
_If_0_jump_to_Label_PRINT_AND_EXIT][S N
T   _Swap][N
S N
N
_Jump_to_Label_INNER_LOOP][N
S S T   N
_Create_Label_PRINT_AND_EXIT][S N
T   _Swap][T    N
S T _Output_integer_to_STDOUT]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

इसे ऑनलाइन आज़माएं (केवल कच्चे स्थानों, टैब और नई-लाइनों के साथ)।

छद्म कोड में स्पष्टीकरण:

मैंने पहले पुनरावर्ती कार्य int f(int n){return n<1?0:n%2+1+3*f(n/2);}को इसके पुनरावृत्त रूप में परिवर्तित किया (छद्म कोड में):

Integer n = STDIN as integer
Add starting_value 0 to the stack
function OUTER_LOOP:
  while(true){
    Add n%2+1 to the stack
    n = n/2
    if(n == 0):
      Jump to INNER_LOOP
    Else:
      Jump to next iteration OUTER_LOOP

function INNER_LOOP:
  while(true){
    n = 3*n
    n = n + Value at the top of the stack (the ones we calculated with n%2+1)
    Swap top two items
    Check if the top is now 0 (starting value):
      Jump to PRINT_AND_EXIT
    Else:
      Swap top two items back
      Jump to next iteration INNER_LOOP

function PRINT_AND_EXIT:
  Swap top two items back
  Print top to STDOUT as integer
  Exit program with error: Exit not defined

और फिर मैंने डिफ़ॉल्ट-स्टैक का उपयोग करते हुए, स्टैक-आधारित भाषा व्हाट्सएप में इस पुनरावृत्त दृष्टिकोण को लागू किया।

उदाहरण चलता है:

इनपुट: 1

Command    Explanation                   Stack           Heap    STDIN   STDOUT   STDERR

SSSN       Push 0                        [0]
SNS        Duplicate top (0)             [0,0]
SNS        Duplicate top (0)             [0,0,0]
TNTT       Read STDIN as integer         [0,0]           {0:1}   1
TTT        Retrieve                      [0,1]           {0:1}
NSSSN      Create Label OUTER_LOOP       [0,1]           {0:1}
 SNS       Duplicate top (1)             [0,1,1]         {0:1}
 SSSTSN    Push 2                        [0,1,1,2]       {0:1}
 TSTT      Modulo top two (1%2)          [0,1,1]         {0:1}
 SSSTN     Push 1                        [0,1,1,1]       {0:1}
 TSSS      Add top two (1+1)             [0,1,2]         {0:1}
 SNT       Swap top two                  [0,2,1]         {0:1}
 SSSTSN    Push 2                        [0,2,1,2]       {0:1}
 TSTS      Int-divide top two (1/2)      [0,2,0]         {0:1}
 SNS       Duplicate top (0)             [0,2,0,0]       {0:1}
 NTSN      If 0: Go to Label INNER_LOOP  [0,2,0]         {0:1}
 NSSN      Create Label INNER_LOOP       [0,2,0]         {0:1}
  SSSTTN   Push 3                        [0,2,0,3]       {0:1}
  TSSN     Multiply top two (0*3)        [0,2,0]         {0:1}
  TSSS     Add top two (2+0)             [0,2]           {0:1}
  SNT      Swap top two                  [2,0]           {0:1}
  SNS      Duplicate top (0)             [2,0,0]         {0:1}
  NTSTN    If 0: Jump to Label PRINT     [2,0]           {0:1}
  NSSTN    Create Label PRINT            [2,0]           {0:1}
   SNT     Swap top two                  [0,2]           {0:1}
   TNST    Print top to STDOUT           [0]             {0:1}           2
                                                                                  error

इसे ऑनलाइन आज़माएं (केवल कच्चे स्थानों, टैब और नई-लाइनों के साथ)।
त्रुटि के साथ रुकता है: बाहर निकलें परिभाषित नहीं।

इनपुट: 4

Command    Explanation                   Stack           Heap    STDIN   STDOUT   STDERR

SSSN       Push 0                        [0]
SNS        Duplicate top (0)             [0,0]
SNS        Duplicate top (0)             [0,0,0]
TNTT       Read STDIN as integer         [0,0]           {0:4}   4
TTT        Retrieve                      [0,4]           {0:4}
NSSSN      Create Label OUTER_LOOP       [0,4]           {0:4}
 SNS       Duplicate top (4)             [0,4,4]         {0:4}
 SSSTSN    Push 2                        [0,4,4,2]       {0:4}
 TSTT      Modulo top two (4%2)          [0,4,0]         {0:4}
 SSSTN     Push 1                        [0,4,0,1]       {0:4}
 TSSS      Add top two (0+1)             [0,4,1]         {0:4}
 SNT       Swap top two                  [0,1,4]         {0:4}
 SSSTSN    Push 2                        [0,1,4,2]       {0:4}
 TSTS      Int-divide top two (4/2)      [0,1,2]         {0:4}
 SNS       Duplicate top (2)             [0,1,2,2]       {0:4}
 NTSN      If 0: Go to Label INNER_LOOP  [0,1,2]         {0:4}
 NSNSN     Jump to Label OUTER_LOOP      [0,1,2]         {0:4}
 SNS       Duplicate top (2)             [0,1,2,2]       {0:4}
 SSSTSN    Push 2                        [0,1,2,2,2]     {0:4}
 TSTT      Modulo top two (2%2)          [0,1,2,0]       {0:4}
 SSSTN     Push 1                        [0,1,2,0,1]     {0:4}
 TSSS      Add top two (0+1)             [0,1,2,1]       {0:4}
 SNT       Swap top two                  [0,1,1,2]       {0:4}
 SSSTSN    Push 2                        [0,1,1,2,2]     {0:4}
 TSTS      Int-divide top two (2/2)      [0,1,1,1]       {0:4}
 SNS       Duplicate top (1)             [0,1,1,1,1]     {0:4}
 NTSN      If 0: Go to Label INNER_LOOP  [0,1,1,1]       {0:4}
 NSNSN     Jump to Label OUTER_LOOP      [0,1,1,1]       {0:4}
 SNS       Duplicate top (1)             [0,1,1,1,1]     {0:4}
 SSSTSN    Push 2                        [0,1,1,1,1,2]   {0:4}
 TSTT      Modulo top two (1%2)          [0,1,1,1,1]     {0:4}
 SSSTN     Push 1                        [0,1,1,1,1,1]   {0:4}
 TSSS      Add top two (1+1)             [0,1,1,1,2]     {0:4}
 SNT       Swap top two                  [0,1,1,2,1]     {0:4}
 SSSTSN    Push 2                        [0,1,1,2,1,2]   {0:4}
 TSTS      Int-divide top two (1/2)      [0,1,1,2,0]     {0:4}
 SNS       Duplicate top (0)             [0,1,1,2,0,0]   {0:4}
 NTSN      If 0: Go to Label INNER_LOOP  [0,1,1,2,0]     {0:4}
 NSSN      Create Label INNER_LOOP       [0,1,1,2,0]     {0:4}
  SSSTTN   Push 3                        [0,1,1,2,0,3]   {0:4}
  TSSN     Multiply top two (0*3)        [0,1,1,2,0]     {0:4}
  TSSS     Add top two (2+0)             [0,1,1,2]       {0:4}
  SNT      Swap top two                  [0,1,2,1]       {0:4}
  SNS      Duplicate top (1)             [0,1,2,1,1]     {0:4}
  NTSTN    If 0: Jump to Label PRINT     [0,1,2,1]       {0:4}
  SNT      Swap top two                  [0,1,1,2]       {0:4}
  NSNN     Jump to Label INNER_LOOP      [0,1,1,2]       {0:4}
  SSSTTN   Push 3                        [0,1,1,2,3]     {0:4}
  TSSN     Multiply top two (2*3)        [0,1,1,6]       {0:4}
  TSSS     Add top two (1+6)             [0,1,7]         {0:4}
  SNT      Swap top two                  [0,7,1]         {0:4}
  SNS      Duplicate top (1)             [0,7,1,1]       {0:4}
  NTSTN    If 0: Jump to Label PRINT     [0,7,1]         {0:4}
  SNT      Swap top two                  [0,1,7]         {0:4}
  NSNN     Jump to Label INNER_LOOP      [0,1,7]         {0:4}
  SSSTTN   Push 3                        [0,1,7,3]       {0:4}
  TSSN     Multiply top two (7*3)        [0,1,21]        {0:4}
  TSSS     Add top two (1+21)            [0,22]          {0:4}
  SNT      Swap top two                  [22,0]          {0:4}
  SNS      Duplicate top (0)             [22,0,0]        {0:4}
  NTSTN    If 0: Jump to Label PRINT     [22,0]          {0:4}
  NSSTN    Create Label PRINT            [22,0]          {0:4}
   SNT     Swap top two                  [0,22]          {0:4}
   TNST    Print top to STDOUT           [0]             {0:4}           22
                                                                                  error

इसे ऑनलाइन आज़माएं (केवल कच्चे स्थानों, टैब और नई-लाइनों के साथ)।
त्रुटि के साथ रुकता है: बाहर निकलें परिभाषित नहीं।

— केविन क्रूज़सेन
स्रोत
इस बिंदु पर, विधानसभा क्यों नहीं लिखी जाती? इसके अलावा, मेरे उत्तर कोडगॉल्फ.स्टैकएक्सचेंज.com
— a
मैंने अपने अजगर के सूडोकोड को और सरल कर दिया है।
— क्वार
1
@qwr आपका पायथन कोड लगभग प्रदर्शित जावा कोड के समान है। जावा सिर्फ अधिक क्रिया और त्रुटि-प्रवण है। अंतर केवल इतना है कि मेरा जावा कोड लूप करते समय नेस्टेड है, और आपका अलग हो गया है। मैं जावा में भी ऐसा कर सकता था, लेकिन चूंकि यह व्हाट्सएप में निहित है इसलिए मैंने इसे जावा स्यूडो-कोड में भी लिखना पसंद किया। इसके अलावा, व्हॉट्सएप के पास स्टैक पर छोड़ी गई वस्तुओं की संख्या को जानने का कोई तरीका नहीं है, यही वजह है कि मैं शुरुआत में 0 को धक्का देता हूं, और कोड के INNER_LOOP हिस्से में: स्वैप करें, जांच करें कि 0, स्वैप वापस। अच्छा विधानसभा जवाब, यद्यपि। तो मैंने इसे + 1-ed किया है। :)
— केविन क्रूज़सेन 20
मुझे अभी भी लगता है कि आप n < 1मानों को धकेल कर चेक से छुटकारा पा सकते हैं जब तक कि n 0 नहीं है और तब तक उन्हें पॉपिंग करें जब तक कि आप अपना सीमा मूल्य (0) नहीं मार लेते। स्टैक की गहराई को स्पष्ट रूप से संग्रहीत करने की आवश्यकता नहीं है और यहां तक ​​कि स्वैप करने की भी आवश्यकता नहीं होनी चाहिए (यदि आपका मतलब है कि लिस्प में शीर्ष दो मानों की
— अदला
@qwr " मुझे अभी भी लगता है कि आप n <1 चेक को मानों को धकेलने से छुटकारा पा सकते हैं जब तक कि n 0 नहीं है " उम्म .. जाँच अगर n < 1(या n == 0) IS मानों nको 0 तक धकेल रहा है .. या मैं यहाँ कुछ गलत कर रहा हूँ ..: S " स्टैक डेप्थ को स्पष्ट रूप से संग्रहीत करने की आवश्यकता नहीं है " जावा में यह करता है, अन्यथा मैं सरणी नहीं बना सकता। मैं java.util.Stackइसके बजाय इस्तेमाल कर सकता था , लेकिन मैंने इसे कम वर्बोज़ बनाने के लिए एक सरणी का उपयोग किया। व्हॉट्सएप में स्टैक अपरिभाषित आकार का है।
— केविन क्रूज़सेन
1

अजगर,,

ihMjQ2 3

कैसे अंतरिक्ष को खत्म करने और बनाने के लिए Q निहित ?

ऑनलाइन पायथ ।

— डिजिटल आघात
स्रोत
मेरा मानना ​​है कि यह वास्तव में 8 बाइट्स है
— hakr14
@ hakr14 हां, आप सही कह रहे हैं
— डिजिटल ट्रामा
अंतरिक्ष को खत्म करने और Qनिहित बनाने के लिए कैसे ? मुझे नहीं लगता कि आप कर सकते हैं।
— एरिक आउटगॉल्फ
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.