हर 2 ^ n बार

Question

आज्ञा देना nबार अपने कार्यक्रम निष्पादित कर दिया गया है की संख्या हो। यदि n2 की शक्ति है, तो प्रिंट 2^xकहां करें n = 2^x; अन्यथा, बस संख्या का उत्पादन। उदाहरण रन:

[1st time] 2^0
[2nd time] 2^1
[3rd time] 3
[4th time] 2^2
[5th time] 5

और इसी तरह। यह एक लोकप्रियता प्रतियोगिता है, इसलिए सबसे अधिक उत्थान के साथ उत्तर जीतता है ।।

Comments

यह 0पहले रन में आउटपुट क्यों करता है ?

— मनिप

क्या आपका मतलब था "कहाँ n = 2^x? वरना दूसरी बार आउटपुट होगा 2^4, चौथी बार 2^16और इसी तरह।

— जॉन ड्वोरक

@ मुन्नीप दोनों टाइपो। मुझे शायद अधिक ध्यान से पढ़ना चाहिए ...: P

— Jwosty

उम्म ... 1दो की एक शक्ति है। 2^0=1

— जॉन ड्वोरक

तुम अब भी कहते हैं कि x = 2^xबजायn = 2^x

— जॉन ड्वोरक

Answer 1

जावा - एपीआई दुर्व्यवहार

ऑनलाइन बहुत सारे कंप्यूटर हैं जो गिनती कर सकते हैं, इसलिए खुद को क्यों स्टोर करें?

कोटा और शेष कोटा प्राप्त करने के लिए स्टैक एपीआई के पूर्ण-दुरुपयोग पर यह देखने के लिए कि इसे आज कितनी बार चलाया गया है:

public static void main(String[] args) throws Exception {
    URLConnection c = new URL("http://api.stackexchange.com/2.2/info?site=stackoverflow").openConnection();
    c.setRequestProperty("Accept-Encoding", "gzip");
    GZIPInputStream gz = new GZIPInputStream(c.getInputStream());
    BufferedReader r = new BufferedReader(new InputStreamReader(gz));
    String reply = r.readLine();
    r.close();

    reply = reply.substring(reply.indexOf("quota_max"), reply.length()-1);
    String[] t = reply.split("[:,]");
    int runs = Integer.parseInt(t[1]) - Integer.parseInt(t[3]);        
    if((runs & (runs -1)) == 0){
        int exp = 0;
        while(runs % 2 == 0){
            runs = runs >> 1;
            exp++;
        }
        System.out.println("2^" + exp);
    } else {
        System.out.println("" + runs);
    }
}

^{जाहिर है यह केवल केवल आपके आईपी के लिए एक ताजा दैनिक कोटा के साथ काम करता है, और अप करने के लिए कोटा। यदि आप उच्च संख्या के लिए समर्थन चाहते हैं, तो जुटाने के quota_maxलिए [सुविधा-अनुरोध] पोस्ट करें MAX_INT।}

Answer 2

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

alert((n=Math.log((l=localStorage).m=~~l.m+1)/Math.log(2))==(n|0)?"2^"+n:l.m)

क्रमिक अलर्ट इस प्रकार हैं:

2^0
2^1
3
2^2
5
6
7
2^3
9
...and so on.

Comments

कृपया धन्यवाद ... 'जावास्क्रिप्ट में निष्पादन का ट्रैक रखने का एकमात्र तरीका ... मैं आगामी जेएस गेम के लिए

— लोकलस्टोरेज

एक काउंटर के रूप में छोटे कुछ के लिए, एक कुकी को भी काम करना चाहिए।

— celtschk

@celtschk महान विचार है, लेकिन मेरा मानना ​​है कि कुकी बनाना अधिक बाइट ले लिया होगा

— WallyWest

Answer 3

सी - निष्पादन योग्य के लिए लेखन

यह सी कोड dataनिष्पादन योग्य में स्ट्रिंग को अपडेट करता है , इसलिए अनिवार्य रूप से यह स्वयं-संशोधित कोड है। यदि आप इसे 9,999,999 बार चलाते हैं, तो आपको दिलचस्प चीजें मिलती हैं।

#include <stdio.h>
#include <stdlib.h>

int main(int argc,char **argv){
    //               'abcdefghijklmnopqrstuvwxyz1' << that's 27 characters inside the quotes
    const char *data="Da best marker in da world 1\0\0\0\0\0\0";
    FILE *f;
    int i,n,m;
    char c;
    long int pos;
    m=n=strtol(data+27,NULL,10);
    i=0;
    while(1){
        if(n==0){
            printf("This code should never have been reached... Unless you've messed with my executable.\n");
            return 1;
        }
        if(n==1){
            printf("2^%d\n",i);
            break;
        }
        if(n&1){
            printf("%d\n",m);
            break;
        }
        i++;
        n>>=1;
    }
    f=fopen(argv[0],"r+b");
    i=0;
    c=fgetc(f);
    while(!feof(f)){
        if(data[i]==c){
            i++;
            if(i==27)break;
        } else i=0;
        c=fgetc(f);
    }
    if(i!=27)return 1;
    n=0;
    pos=ftell(f);
    c=fgetc(f);
    while(c!='\0'){
        n=10*n+c-'0';
        c=fgetc(f);
    }
    n++; //The big increment!
    fseek(f,pos,SEEK_SET);
    fprintf(f,"%d",n);
    fflush(f);
    fclose(f);
    return 0;
}

Comments

: यह विभाजन दोष जीसीसी 4.8.1-10ubuntu9 साथ यह संकलन के बाद gcc test.c,./a.out 2^0 Segmentation fault (core dumped)

— TimWolla

मैक पर यह काम करता है, लिनक्स या विंडोज़ की कोशिश नहीं की है। जाहिर तौर पर लिनक्स खुद को एक्सेस करने के साथ अधिक सख्त है।

— tomsmeding

Answer 4

जावा

निम्न कोड संशोधित करता है कि नई रन गणना को संग्रहीत करने के लिए यह स्वयं की वर्ग फ़ाइल है। यह विशेष रूप से मजेदार था जब आपको पता नहीं था कि बाइट कोड कैसा दिखता है, लेकिन Googling और परीक्षण के अनगिनत घंटों के बाद यह आखिरकार काम करता है! :)

डेमो (डेमो उद्देश्यों के लिए शुरुआती मूल्य के रूप में 7 का उपयोग करते हुए):

[timwolla@/data/workspace/java]javac Runs.java 
[timwolla@/data/workspace/java]java Runs 
7
[timwolla@/data/workspace/java]java Runs 
2^3
[timwolla@/data/workspace/java]java Runs 
9
[timwolla@/data/workspace/java]java Runs 
10

कोड:

import java.io.*;
import java.util.*;

class Runs {

    public static void main(String[] args) throws Exception {
        // RUN-- makes the string easy to find in the byte code
        String runString = "RUN--1";

        // extract the number
        int runs = Integer.parseInt(runString.substring(5));

        // output the number properly
        int power = 0;
        boolean outputted = false;
        while (Math.pow(2, power) <= runs) {
            if (Math.pow(2, power) == runs) {
                outputted = true;
                System.out.println("2^"+power);
            }
            power++;
        }
        if (!outputted) System.out.println(runs);

        // increase run count
        runs++;

        // build new string
        String newRunString = runString.substring(0, 5) + runs;

        // get folder of class file
        String folder = Runs.class.getProtectionDomain().getCodeSource().getLocation().getFile();
        // append class file name
        String me = folder + "/Runs.class";

        // and open it up
        RandomAccessFile in = new RandomAccessFile(me, "rw");

        int read;
        int state = 0;
        while ((read = in.read()) != -1) {
            char c = (char) read;

            // state machine to find the RUN--
            switch (state) {
                case 0:
                    // 2 bytes before: upper byte of the two byte length
                    if (c == ((runString.length() >> 8) & 0xFF)) state++;
                break;
                case 1:
                    // 1 byte before: lower byte of the two byte length
                    if (c == (runString.length() & 0xFF)) state++;
                    else state = 0;
                break;
                case 2:
                    if (c == 'R') state++;
                    else state = 0;
                break;
                case 3:
                    if (c == 'U') state++;
                    else state = 0;
                break;
                case 4:
                    if (c == 'N') state++;
                    else state = 0;
                break;
                case 5:
                case 6:
                    if (c == '-') state++;
                    else state = 0;
                break;
                case 7:
                    // we found run, now: Modify byte code

                    // back to the bytes that determine the length
                    in.seek(in.getFilePointer() - 8);

                    // expand the file if neccessary
                    int lengthChange = (newRunString.length() - runString.length());
                    in.setLength(in.length() + lengthChange);

                    // write new length
                    in.writeByte(((newRunString.length() >> 8) & 0xFF));
                    in.writeByte((newRunString.length() & 0xFF));

                    // length changed, shift all the following bytes by one
                    if (lengthChange > 0) {
                        long target = in.getFilePointer();
                        in.seek(in.length() - 1 - lengthChange);
                        while (in.getFilePointer() > target) {
                            in.write(in.read());
                            in.seek(in.getFilePointer() - 3);
                        }
                        in.seek(target);
                    }

                    // write new string
                    in.writeBytes(newRunString);

                    return;
                case 8:
            }
        }
    }
}

Answer 5

डीजी

यहाँ मैं आपको एक पोर्टेबल कोड प्रस्तुत करता हूँ! हर रन #पर एक अंत में जोड़ा जाता है, जिससे एक प्रगति बार बनता है! इसके अलावा, आप कोड को किसी अन्य मशीन पर ले जा सकते हैं और फिर से शुरू कर सकते हैं।

import '/math'

with fd = open __file__ 'r' =>
  code = fd.read!
  times = code.count('#') - 2
with fd = open __file__ 'w' =>
  fd.write $ code.rstrip! + '#'
exp = math.log2 times
if exp.is_integer! => print $ '2^{}'.format $ int exp
   otherwise => print times

#

18 बार के बाद:

import '/math'

with fd = open __file__ 'r' =>
  code = fd.read!
  times = code.count('#') - 2
with fd = open __file__ 'w' =>
  fd.write $ code.rstrip! + '#'
exp = math.log2 times
if exp.is_integer! => print $ '2^{}'.format $ int exp
   otherwise => print times

###################

Comments

आह, मुझे इस भाषा को इंगित करने के लिए धन्यवाद। यह शामिल है कि मैं पायथन और हास्केल दोनों के बारे में क्या प्यार करता हूं।

— काया

@ काया मुझे खुशी है कि आप इसे पसंद करते हैं! यदि आपने पहले से नहीं देखा है, तो pyos.github.io/dg पर एक होमपेज और एक ट्यूटोरियल भी है! बहुत सारा माल। और अगर आपको ऐसा लगता है तो रिपॉजिटरी पर एक मुद्दे को खोलने में संकोच न करें। संपादित करें: मैं सिर्फ यह बताना चाहता था कि मैं इस रचनाकार का नहीं हूं।

— माणिक

Answer 6

सिनात्रा-आधारित रूबी उदाहरण

यह सर्वर-आधारित समाधान कुकी में प्रत्येक उपयोगकर्ता के लिए एक व्यक्तिगत काउंटर संग्रहीत करता है।

इसे http://every-2-to-the-n-times.herokuapp.com/ पर आज़माएं

require 'sinatra'
require 'sinatra/cookies'

# https://github.com/sinatra/sinatra-contrib/issues/113
set :cookie_options, :domain => nil

get '/' do
   x = cookies[:x].to_i || 1
   cookies[:x] = x + 1

   # power of 2 test from http://grosser.it/2010/03/06/check-if-a-numer-is-a-power-of-2-in-ruby/
   return (x & (x - 1) == 0) ? "2^#{Math.log2(x).to_i}" : x.to_s
end

Answer 7

पर्ल

यहाँ यह करने के लिए पर्ल का एक छोटा सा है। डेटा कहाँ संग्रहीत किया जाना चाहिए? प्रोग्राम फ़ाइल में ही क्यों! =)

$b = sprintf '%b', $x=x();
print $b=~/^10*$/ ? "2^".(length($b)-1) : $x, "\n";
open F, "+<", $0;
seek F, -3-length $x, 2;
print F $x+1, " }\n";
sub x { 1 }

मूल रूप से मैंने जादू DATA फ़ाइल हैंडल का उपयोग किया था, लेकिन मुझे लगता है कि उपरोक्त "शुद्ध" है।

$b = sprintf '%b', $x = <DATA>;
print $b =~ /^10*$/ ? "2^".(length($b)-1)."\n" : $x;
open F, "+<", $0;
seek F, -length $x, 2;
print F $x+1, "\n";
__DATA__
1

Comments

आप tell DATAइसे पढ़ने से पहले स्टोर कर सकते हैं , फिर उस स्थान पर वापस आ सकते हैं।

— भीड़

Answer 8

दे घुमा के

सरल स्व-संपादन शेल स्क्रिप्ट।

n=1;e=0;p=1
sed -i s/"n=$n"/"n=`expr $n + 1`"/g $0
if [[ $n -eq $p ]];then
    echo 2^$e
    sed -i s/"p=$p"/"p=`expr $p \* 2`"/g $0
    sed -i s/"e=$e"/"e=`expr $e + 1`"/g $0
else
    echo $n
fi

Answer 9

दे घुमा के

मुझे dfernig का बैश समाधान पसंद है , लेकिन मैं अपना पोस्ट भी करना चाहूंगा:

n=$(expr `cat $0|wc -c` - 170)
if [ $(echo "obase=2;$n"|bc|grep -o 1|wc -l) == 1 ]
then echo -n "2^"; echo "obase=2;$n"|bc|grep -o 0|wc -l;
else echo $n; fi
echo "" >> $0

मुझे लगता है कि समाधान को अलग माना जा सकता है, क्योंकि

• वास्तव में निष्पादित कोड परिवर्तित नहीं होता है
• कार्यक्रम dinamically की गणना करता है, तो एन 2 के एक शक्ति है

"मेमोरी" स्क्रिप्ट आकार (शुरुआत में 171 बाइट्स) है, जिसे प्रत्येक निष्पादन पर एक नई पंक्ति के परिशिष्ट के साथ 1 से बढ़ाया जाता है।
2 की शक्तियों को प्रोग्राम आकार (शून्य से 170, निश्चित रूप से) को बाइनरी में परिवर्तित करके, और फिर लोगों को गिनकर पहचाना जाता है: यदि वास्तव में एक है, तो n की शक्ति 2 है। घातांक बाइनरी में शून्य की संख्या है ।

Answer 10

जावा समाधान

रन वरीयताओं को संग्रहीत करने के लिए जावा वरीयताओं एपीआई का उपयोग करना; और एक हैशमाप के लिए तुलना करने के लिए 2 की शक्तियों को पहले से निर्धारित किया

import java.util.HashMap;
import java.util.prefs.Preferences;
class Pow
{
    public static void main(String[]a)
    {
        int rt = Integer.valueOf(Preferences.userRoot().get("Pow.run", "1"));
        HashMap<String,Integer> powof2 = new HashMap<>();
        //pregenerating the powers of 2;
        for (int i = 0; i < 46340; i++)//highest power of 2 before int overflow
        {
            powof2.put(((int)Math.pow(2, i))+"",i);
        }
        if(powof2.containsKey(rt+""))
        {System.out.println("2^"+powof2.get(rt+""));}
        else
        {
            System.out.println(rt);
        }
        rt++;
        Preferences.userRoot().put("Pow.run", ""+(rt));
    }
}

Answer 11

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

मैंने स्पष्ट log2समाधान का उपयोग नहीं करने का फैसला किया, लेकिन 2 नंबर की शक्ति के द्विआधारी प्रतिनिधित्व में एकल बिट स्थिति को खोजने के लिए बिटवाइज़ ऑपरेटरों के साथ काम किया।

Number.prototype.singleBitPosition = function() {
  var r=1, k;
  if (this==0) return -1;
  while(this==(k=this>>r<<r)) r++; //set r last bits to zero and compare
  return k?-1:r; //if k is zero, there is one single bit to 1 in number representation ie power of 2
};

var n;
if (n === undefined) n=0;
n++;

var e = n.singleBitPosition();
if (e > 0) {
  console.log('2^'+(e-1));
} else {
  console.log(n);
}

Comments

महान रणनीति, लेकिन दुर्भाग्य से, संक्षिप्त में कहा गया है कि इसे निष्पादित किए गए समय की संख्या के मूल्य को प्रदर्शित करने की आवश्यकता है, तदनुसार प्रदान किया गया ... तुम्हारा सिर्फ for1 से 130 तक का लूप है, प्रतिपादन के साथ ...: /

— वैलीवेस्ट

@WallyWest, हाँ, यह इंगित करने के लिए धन्यवाद।

— माइकल एम।

कोई अपराध का इरादा नहीं ...

— वैलीवेस्ट

मैंने आपकी टिप्पणी को अपराध के रूप में नहीं लिया था, यह एक वास्तविक धन्यवाद था! क्षमा करें, यदि मेरे शब्दों को अच्छी तरह से नहीं चुना गया है, तो अंग्रेजी मेरी मातृभाषा नहीं है।

— माइकल एम।

Answer 12

माणिक

ठीक है, मुझे लगता है कि मैं अब यह कोशिश करूँगा। यह स्वयं की परिभाषा के लिए खोज करता है n।

def p2 n
  n == 1 ? 0 : p2(n >> 1) + 1
end
n = 1
if (n != 0) & (n & (n - 1) == 0) || n == 1
  puts("2^" + (p2(n).to_s))
else
  puts n
end

contents = File.read(__FILE__)
newContents = contents.gsub(/(?<=n \= )[0-9]+/) {|n| (n.to_i + 1).to_s}
File.write(__FILE__, newContents)

(रूबी 1.9.3 में परीक्षण किया गया)

Answer 13

फोरट्रान 77

कोड:

      program twok
      rewind 1
      read(1,'(I20,I3)',end=10,err=30)n,k
      go to 20
10    n=-1
      k=0
20    n=n+1
      if (n .eq. 2**k) then
        if (k.le.9) then
          write(*,'(A3,i1)')' 2^',k
        else
          write(*,'(A3,i2)')' 2^',k
        endif
        k=k+1
      else
        write(*,*)n
      endif
      if (n .lt. 0) then
         n=-1
         k=0
      endif
      rewind 1
      write(1,'(I20,I3)')n,k
30    continue
      end

परिणाम:

$ ./a.out       !       $ ./a.out
 2^0            !        2^1
$ ./a.out       !
 2^1            !       $ while true
$ ./a.out       !       > do
 3              !       > ./a.out | grep "2^"
$ ./a.out       !       > done
 2^2            !        2^2
$ ./a.out       !        2^3
 5              !        2^4
$ ./a.out       !        2^5
 6              !        ...
...             !        2^12
$ ./a.out       !        2^13
 2147483647     !       ^C # (after about 5 minutes)
$ ./a.out       !       $ ./a.out
 2^31           !        14718
$ ./a.out       !       $ ./a.out
 0              !        14719
$ ./a.out       !       $
 2^0            !

Comments

यह एक विशेष निर्देशिका के भीतर किए गए रनों की संख्या को गिनाता है। संभव सुधार / tmp निर्देशिका में एक फ़ाइल का अनुरोध करने के लिए होगा, और एक ही समय में काउंटर को अद्यतन करने का प्रयास नहीं करने के लिए एक से अधिक उदाहरण जोड़ने के लिए।

— ग्लेन रैंडर्स-पीरसन

Answer 14

सी

इसे करने के लिए "उचित" तरीकों में से एक (फ़ाइलों का उपयोग किए बिना, वह है)।

आप resetइसे वापस शून्य पर सेट करने के लिए कमांड लाइन पर दे सकते हैं । आप निष्पादन योग्य को चारों ओर स्थानांतरित या कॉपी भी कर सकते हैं। निष्पादन योग्य स्थानांतरित करना इसे रीसेट करता है, और निष्पादन योग्य की कई प्रतियां स्वतंत्र हैं।

#include <stdio.h>
#include <sys/msg.h>
#include <sys/shm.h>

int main(int argc, char **argv) {
   // get a shared memory segment associated with our program
   long key = ftok(argv[0], 1);
   long id = shmget(key, sizeof(long), 0666 | IPC_CREAT);
   long *num = (long*) shmat(id, NULL, 0);

   // reset parameter
   if (argc == 2 && !strcmp(argv[1], "reset")) {
      *num = 0;
   }

   if (*num & *num-1) {
      // not a power of two
      printf("%li\n", *num);
   } else {
      // power of two
      int exp = 0;
      int n=*num;
      while (n >>= 1) exp++;
      printf("2^%d\n", exp);
   }

   ++*num;

   // detach from shared memory
   shmdt(num);
   return 0;
}

Answer 15

स्पार्कलिंग, 423 वर्ण (अभी तक एक और स्व-संशोधित कोड)। इसे count.spnतब चलाएं जब तक बचाएं spn count.spn:

var n =
19
;

var l = log2(n);
if l == floor(l) {
    printf("2 ^ %d\n", floor(l));
} else {
    printf("%.0f\n", n);
}

var f = fopen("count.spn", "rb");
var g = fopen("count.spn.2", "wb");
var line = fgetline(f);
fprintf(g, "%s", line);
fprintf(g, "%d\n", n + 1);
fgetline(f);

while (line = fgetline(f)) != nil {
    fprintf(g, "%s", line);
}

fclose(f);
fclose(g);

Answer 16

यहाँ एक त्वरित पायथन 3 समाधान है, जो स्टोर करने nऔर xरन के बीच डेटा फ़ाइल का उपयोग करता है :

try:
    with open("count.txt") as f:
        n, x = map(int, f.readline().split())
except FileNotFoundError:
    n = x = 0

n += 1
if n == 2**x:
    print("2^{}".format(x))
    x += 1
else:
    print(n)

with open("count.txt", "w") as f:
    f.write("{} {}".format(n, x))

इसे 16 बार चलाने का आउटपुट:

2^0
2^1
3
2^2
5
6
7
2^3
9
10
11
12
13
14
15
2^4

Answer 17

अजगर २

import inspect
import math

file_name = inspect.getfile(inspect.currentframe())

n = int(open(file_name).readlines()[-1].strip())

l = math.log(n, 2)
if int(l) == l:
    print '2^%d' % (l)
else:
    print n

with open(file_name, 'a') as f:
    f.write('%d\n' % (n + 1))

1

Answer 18

सी#

static void Main()
{
  ulong cnt         = ++Properties.Settings.Default.NumberOfExecutions ;
  int?  log2        = Log2( cnt ) ;
  Console.WriteLine( log2.HasValue ? "2^{0}" : "{1}" , log2 , cnt ) ;
  Properties.Settings.Default.Save() ;
  return ;
}

static int? Log2( ulong m )
{
  int? n = null ;
  if ( m > 0 )
  {
    n = 0 ;

    // find the first set bit
    ulong mask = 0x0000000000000001ul ;
    while ( mask != 0 && 0ul == (m&mask) )
    {
      mask <<= 1 ;
      ++n ;
    } ;

    // if the mask is identical to m,
    // we've got a power of 2: return n, otherwise null
    n = mask == m ? n : null ;

  }
  return n ;
}

हालाँकि, यह आवश्यक है कि आप अपने विज़ुअल स्टूडियो प्रोजेक्ट में सेटिंग्स प्रॉपर्टी को परिभाषित करें:

Answer 19

सी / POSIX

यह प्रोग्राम अपने स्वयं के निष्पादन योग्य हार्ड लिंक की संख्या का उपयोग करता है क्योंकि यह कितनी बार कहा जाता था। यह उस निर्देशिका से नई हार्ड लिंक बनाता है जिसे इसे शुरू किया गया था (क्योंकि यह उसी तरह की फ़ाइल सिस्टम पर होने की गारंटी है), जिसे इसलिए अनुमति की आवश्यकता है। मैंने त्रुटि हैंडलिंग छोड़ दी है।

आप बेहतर तरीके से सुनिश्चित करते हैं कि आपके पास उस निर्देशिका में बनाई गई हार्ड लिंक में से एक के समान नाम वाली कोई महत्वपूर्ण फ़ाइल नहीं है, या इसे अधिलेखित कर दिया जाएगा। यदि उदाहरण के लिए निष्पादन योग्य नाम दिया गया है counter, तो हार्ड लिंक का नाम होगा counter_1, counter_2आदि।

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char* argv[])
{
  /* get persistent counter */
  struct stat selfstat;
  stat(argv[0], &selfstat);
  int counter = selfstat.st_nlink;

  /* determine digits of counter */
  int countercopy = counter;
  int digits = 1;
  while (countercopy /= 10)
    ++digits;

  /* increment persistent counter */
  char* newname = malloc(strlen(argv[0]) + digits + 2);
  sprintf(newname, "%s_%d", argv[0], counter);
  link(argv[0], newname);

  /* output the counter */
  if (counter & (counter-1)) // this is zero iff counter is a power of two
    printf("%d\n", counter);
  else
  {
    /* determine which power of 2 it is */
    int power = 0;
    while (counter/=2)
      ++power;
    printf("2^%d\n", power);
  }
  return 0;
}

उदाहरण रन (पहली पंक्ति काउंटर रीसेट करता है, यदि निष्पादन योग्य पहले ही चला दिया गया हो):

$ rm counter_*
$ ./counter
2^0
$ ./counter
2^1
$ ./counter
3
$ ./counter
2^2
$ ./counter
5
$ ./counter
6
$ ./counter
7
$ ./counter
2^3
$ ./counter
9
$ ls counter*
counter    counter_2  counter_4  counter_6  counter_8  counter.c
counter_1  counter_3  counter_5  counter_7  counter_9  counter.c~

Answer 20

फोरट्रान 95

"ए" (एक्सटेंशन के बिना) नामक एक फ़ाइल प्रोग्राम के रन का ट्रैक रखती है।

logical::l
inquire(file="a",exist=l)
open(unit=11,file="a")
if (l) then
  read(11,*)n
  close(unit=11,status="delete")
  open(unit=11,file="a")
  n=n+1
  write(11,*)n
  do i=1,n
    if (2**i==n) then
      write(*,"(A2,I1)")"2^",i
      goto 1        
    endif
  enddo
  print*,n
  else
    print*,"2^0"
    write(11,*)1
endif
1 end