อนุญาตnเป็นจำนวนครั้งที่โปรแกรมของคุณถูกเรียกใช้งาน ถ้าnเป็นพลังของ 2 แล้วพิมพ์2^xที่ไหนn = 2^x; มิฉะนั้นเพียงแค่ส่งออกจำนวน ตัวอย่างการเรียกใช้:

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

และอื่น ๆ นี่คือการประกวดความนิยมดังนั้นคำตอบของผู้ชนะมากที่สุดคือผู้ชนะ

Java - การละเมิด API

มีคอมพิวเตอร์มากมายที่ออนไลน์ที่สามารถนับได้ดังนั้นทำไมต้องจัดเก็บการนับด้วยตัวเอง

การใช้ API แบบเต็มรูปแบบในทางที่ผิดเพื่อรับโควต้าและโควต้าที่เหลือเพื่อดูว่ามีการใช้งานกี่ครั้งในวันนี้:

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

JavaScript

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.

C - เขียนไปยังปฏิบัติการ

รหัส C นี้อัพเดตสตริง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;
}

ชวา

รหัสต่อไปนี้แก้ไขไฟล์คลาสของตัวเองเพื่อเก็บจำนวนรันใหม่ นี่เป็นเรื่องสนุกโดยเฉพาะอย่างยิ่งเมื่อคุณไม่มีความคิดว่าโค้ดไบต์มีลักษณะอย่างไร แต่หลังจากผ่านไปหลายชั่วโมงกับ 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:
            }
        }
    }
}

DG

ที่นี่ฉันจะนำเสนอรหัสแบบพกพาให้คุณ! ทุกครั้งที่รัน a #จะถูกเพิ่มในตอนท้ายสร้างแถบความคืบหน้า! นอกจากนี้คุณสามารถย้ายรหัสไปยังเครื่องอื่นและดำเนินการต่อจากที่ที่คุณอยู่

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

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

ตัวอย่างทับทิมจากซินาตร้า

โซลูชันที่ใช้เซิร์ฟเวอร์นี้จะจัดเก็บตัวนับส่วนบุคคลสำหรับผู้ใช้แต่ละรายในคุกกี้

ลองที่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

Perl

นี่คือ 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 }

แต่เดิมฉันได้ใช้ตัวจัดการไฟล์ magic data อย่างเช่นนั้น แต่ฉันรู้สึกว่าข้างต้นคือ "purer":

$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

ทุบตี

เชลล์สคริปต์การแก้ไขตัวเองง่าย ๆ

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

ทุบตี

ฉันชอบdashnig 's Bash solutionแต่ฉันต้องการโพสต์ของฉันด้วย:

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

ฉันคิดว่าวิธีแก้ปัญหานั้นอาจแตกต่างออกไปเพราะ

• รหัสที่ใช้จริงจะไม่เปลี่ยนแปลง
• โปรแกรมคำนวณโดยอัตโนมัติหากnคือพลังของ 2

"หน่วยความจำ" คือขนาดสคริปต์ (เริ่มแรก 171 ไบต์) ซึ่งเพิ่มขึ้น 1 โดยผนวกบรรทัดใหม่ในแต่ละการดำเนินการ
พลังของ 2 ได้รับการยอมรับโดยการแปลงขนาดของโปรแกรม (ลบ 170 ของหลักสูตร) ​​เป็นไบนารี่แล้วนับจำนวน: ถ้ามีอย่างใดอย่างหนึ่งหนึ่งแล้วnคือพลังของ 2 เลขชี้กำลังเป็นจำนวนศูนย์ในไบนารี .

โซลูชัน Java

กำลังใช้ API การกำหนดค่าตามความชอบ Java เพื่อเก็บจำนวนรัน และคำนวณพลังของ 2 สำหรับ hashmap เพื่อเปรียบเทียบ

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

จาวาสคริ

ฉันเลือกที่จะไม่ใช้log2โซลูชันที่ชัดเจนแต่ทำงานร่วมกับตัวดำเนินการระดับบิตเพื่อค้นหาตำแหน่งบิตเดียวในการแสดงเลขฐานสองของกำลังสองจำนวน

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

ทับทิม

เอาล่ะฉันคิดว่าฉันจะลองตอนนี้ 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)

(ทดสอบใน Ruby 1.9.3)

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

ค

หนึ่งในวิธี "เหมาะสม" ในการดำเนินการ (โดยไม่ต้องใช้ไฟล์นั่นคือ)

คุณสามารถให้มัน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;
}

ตัวอักษรมีประกายระยิบระยับ 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);

ต่อไปนี้เป็นโซลูชัน Python 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

Python 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

ค#

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

อย่างไรก็ตามสิ่งนี้ต้องการให้คุณกำหนดคุณสมบัติการตั้งค่าในโครงการ Visual Studio ของคุณ:

C / 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~

Fortran 95

ไฟล์ชื่อ "a" (ไม่มีส่วนขยาย) ติดตามการทำงานของโปรแกรม

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