প্রতি 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ইত্যাদি।

— জন ডিভোরাক

@ এমনিপ দুটি টাইপ। আমার সম্ভবত এটি আরও মনোযোগ সহকারে পড়া উচিত ছিল ...: পি

— জোস্টি

উম্ম ... 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);
    }
}

^{একথাও ঠিক যে এই শুধুমাত্র শুধুমাত্র আপনার IP জন্য একটি তাজা দৈনিক কোটার সাথে কাজ করে, এবং পর্যন্ত কোটা। আপনি উচ্চতর সংখ্যার জন্য সমর্থন চান, একটি [বৈশিষ্ট্য অনুরোধ] বাড়াতে পোষ্ট 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

@ এসএলটস্ক্ক দুর্দান্ত ধারণা, তবে আমি বিশ্বাস করি একটি কুকি তৈরি করতে আরও বাইটস নেওয়া হত

— ওয়াল ওয়েস্ট

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

ম্যাকে এটি কাজ করে, লিনাক্স বা উইন্ডোজ চেষ্টা করেনি। স্পষ্টতই লিনাক্স নিজেকে অ্যাক্সেস করার সাথে আরও কঠোর।

— টমসডিং

Answer 4

জাভা

নিম্নলিখিত রানটি নতুন রান গণনা সংরক্ষণের জন্য নিজের শ্রেণীর ফাইলকে সংশোধন করে। এটি বিশেষত মজার ছিল যখন বাইট কোডটি কীভাবে দেখায় আপনার কোনও ধারণা ছিল না তবে গুগলিং এবং টেস্টিংয়ের অসংখ্য ঘন্টা পরে অবশেষে এটি কার্যকর হয়! :)

ডেমো (ডেমো উদ্দেশ্যে starting টি প্রারম্ভিক মান হিসাবে ব্যবহার করে):

[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

আহ, এই ভাষাটি আমাকে দেখানোর জন্য ধন্যবাদ thanks পাইথন এবং হাস্কেল উভয়েরই সম্পর্কে আমি যা ভালবাসি তা এতে অন্তর্ভুক্ত করে।

— কেয়া

@ কেয়া আমি আনন্দিত আপনি এটি পছন্দ করেছেন! আপনি যদি ইতিমধ্যে দেখেন নি, 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

Perl

এটি করার জন্য এখানে পার্লের একটি ছোট্ট বিট। কোথায় তথ্য সংরক্ষণ করা উচিত? প্রোগ্রামের ফাইলটিতেই কেন, অবশ্যই! =)

$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 }

মূলত আমি যেমন ম্যাজিক ডেটা ফাইল হ্যান্ডেলটি ব্যবহার করেছি তবে আমার মনে হয় উপরেরটি "বিশুদ্ধ":

$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

আমি মনে করি সমাধানটি ভিন্ন হিসাবে বিবেচনা করা যেতে পারে, কারণ

• আসলে কার্যকর করা কোডটি পরিবর্তন হয় না doesn't
• প্রোগ্রামটি ডাইনামিকভাবে গণনা করে যে এন 2 এর পাওয়ার হয়

"মেমরি" হ'ল স্ক্রিপ্ট আকার (প্রথম দিকে 171 বাইট), যা প্রতিটি সম্পাদনে একটি নতুন লাইন যুক্ত হওয়ার সাথে সাথে 1 দ্বারা বৃদ্ধি করা হয়।
2 এর শক্তিগুলি প্রোগ্রাম আকার (মাইনাস 170, অবশ্যই) বাইনারি রূপান্তরিত করে এবং তারপরে একটিগুলি গণনা করে স্বীকৃত হয়: যদি ঠিক এক থাকে তবে n এর একটি শক্তি 2 হয় The ।

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 লুপ, রেন্ডারিং সঙ্গে ...: /

— ওয়ালিওয়েস্ট

@ ওয়েলওয়েস্ট, হ্যাঁ, এটি নির্দেশ করার জন্য ধন্যবাদ।

— মাইকেল এম 12

কোনও অপরাধের উদ্দেশ্যে নয় ...

— ওয়াল ওয়েস্ট

আমি আপনার মন্তব্যটিকে অপরাধ হিসাবে গ্রহণ করি নি, এটি ছিল সত্যিকারের ধন্যবাদ! দুঃখিত যদি আমার শব্দগুলি সঠিকভাবে না বেছে নেওয়া হয় তবে ইংরেজি আমার মাতৃভাষা নয়।

— মাইকেল এম 13

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)

(রুবি ১.৯.৩ এ পরীক্ষিত)

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

এটি একটি নির্দিষ্ট ডিরেক্টরিতে করা রানগুলির সংখ্যা গণনা করে। সম্ভাব্য উন্নতি হ'ল / টিএমপি ডিরেক্টরিতে কোনও ফাইলের জন্য অনুরোধ করা, এবং একটি সেমফোর যুক্ত করা যাতে একাধিক উদাহরণ একই সাথে কাউন্টারটি আপডেট করার চেষ্টা না করে।

— গ্লেন রেন্ডার্স-পেহারসন

Answer 14

সি

এটি করার একটি "যথাযথ" উপায়গুলির মধ্যে (ফাইলগুলি ব্যবহার না করেই, তা)।

আপনি resetএটিকে শূন্যে সেট করতে কমান্ড লাইনে দিতে পারেন । এক্সিকিউটেবলকে চারপাশে স্থানান্তর বা অনুলিপি করতে পারেন। এক্সিকিউটেবলকে সরানো এটিকে পুনরায় সেট করে এবং এক্সিকিউটেবলের একাধিক অনুলিপি স্বাধীন are

#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

স্পার্কলিং, ৪২৩ টি অক্ষর (অন্য একটি স্ব-সংশোধনকারী কোড)। এটি 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

পাইথন 2

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