Utas polisi dapat ditemukan di sini: The Mystery String Printer (Cops)

Tantanganmu

• Pilih kiriman dari utas polisi, dan cetak utas dari jawaban di utas itu.
• Kiriman yang Anda pilih tidak boleh aman (harus lebih baru dari 7 hari).

• Program, fungsi, atau skrip REPL Anda harus mengikuti aturan yang sama dengan utas polisi. Hanya untuk rekap:

  • Program Anda harus ≤128 karakter (jika pengiriman polisi dalam rentang panjang program yang lebih kecil, program Anda juga harus dalam rentang panjang itu. Misalnya, jika program polisi adalah ≤32 byte, program Anda harus ≤32 byte ).
  • Program harus menghasilkan output yang sama setiap kali dijalankan.
  • Tidak ada fungsi kriptografi.
  • Program tidak boleh mengambil input.
  • Tidak ada celah standar.
• Semua kiriman baru harus menggunakan bahasa yang sama. Pengajuan dari sebelum aturan ini dibuat baik-baik saja, bahkan jika mereka tidak melakukannya.

Mencetak gol

Pemberian skor sama untuk perampok, tetapi sedikit berbeda:

• Meretakkan program ≤8 byte memberikan 1 poin.
• Meretakkan program ≤16 byte memberikan 2 poin. ≤32 byte memberikan 4 poin, dan seterusnya.
• Setiap pengiriman tambahan, berapa pun panjangnya, menghasilkan +5 poin
• Setiap pengajuan polisi hanya dapat dipecahkan satu-satunya orang pertama yang memecahkan setiap pengajuan mendapatkan poin.

Pengajuan

Setiap jawaban harus disertakan

• Tautan ke pengajuan polisi.
• Program dan bahasa pemrograman Anda.
• Juga memiliki panjang program polisi (sebagai kekuatan 2) sebagai angka terakhir di header Anda.

Selain itu, silakan komentari kiriman polisi dengan tautan ke jawaban Anda.

Berikut ini adalah Stack Snippet untuk menghasilkan papan peringkat. Silakan tinggalkan komentar jika ada masalah dengan cuplikan. Jika Anda ingin melihat semua pengiriman polisi terbuka, lihat cuplikan dalam tantangan polisi.

/* Configuration */

var QUESTION_ID = 60329; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";

/* App */

var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;

function answersUrl(index) {
  return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {

  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });

}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {

        answers_hash[c.post_id].comments.push(c);

      });

      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;


function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {

  var valid = [];
  var open = [];

  answers.forEach(function(a) {

    var body = a.body;
    var cracked = false;

    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);

    if (points) {
      var length = parseInt(points[1]);
      var crackedpoints = 0;
      if (length > 64) crackedpoints = 16;
      else if (length > 32) crackedpoints = 8;
      else if (length > 16) crackedpoints = 4;
      else if (length > 8) crackedpoints = 2;
      else crackedpoints = 1;

      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: 1,
        points: crackedpoints

      });
    }
  });

  var pointTotals = [];
  valid.forEach(function(a) {

    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });

    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions++;
    }

  });

  pointTotals.forEach(function(a) {
    a.points += +((a.numberOfSubmissions - 1) * 5);
  });

  pointTotals.sort(function(a, b) {
    var aB = a.points,
      bB = b.points;
    return (bB - aB != 0) ? bB - aB : b.numberOfSubmissions - a.numberOfSubmissions;
  });

  pointTotals.forEach(function(a) {


    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SUBMISSIONS}}", a.numberOfSubmissions)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);


  });

}

body {
  text-align: left !important
}
#answer-list {
  padding: 20px;
  width: 240px;
  float: left;
}
#open-list {
  padding: 20px;
  width: 450px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Robber's Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>

        <td>Author</td>
        <td>Submissions</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>

<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SUBMISSIONS}}</td>
      <td>{{POINTS}}</td>
    </tr>
  </tbody>
</table>

Kontes ini sudah ditutup.

Pemenang keseluruhan: kennytm

Sebagian besar pengiriman: Sp3000

(Perhatikan bahwa jumlah pengiriman tidak menerjemahkan dengan tepat ke poin, karena panjang program yang retak dihitung saat menghitung skor).

Pyth, Dennis, ≤ 8

V./Tp*FN

Sialan itu menyenangkan - bagian tersulit adalah mencari tahu bagaimana melakukannya cukup pendek di Pyth.

Analisis

Pada 1234awalnya mengisyaratkan bahwa kita mungkin berurusan dengan daftar angka, dicetak tanpa pemisah. Mari kita coba dan pisahkan angka-angka dengan cara yang masuk akal:

1 2 3 4 4 6 5 8 8 9 6 12 10 12 7 16 16 18 12 15 16 8 24 20 24 14 27 18 20 9 32 32 36 24 30 32 16 36 21 24 25 10

Ada beberapa petunjuk bahwa kita berada di jalur yang benar:

• Semua angka memiliki faktor prima kurang dari 10
• Banyak angka yang cukup dekat dengan indeks mereka dalam daftar

Namun, ada beberapa kekhasan. Angka pada indeks 23 adalah 24, dan merupakan satu-satunya kasus di mana angka pada indeks lebih besar dari indeks itu sendiri. Namun, petunjuk yang lebih besar adalah bahwa beberapa angka jelas lebih kecil dari tetangga mereka, terutama angka 7 pada indeks 15, 8 pada indeks 22 dan 9 pada indeks 30.

Memperhatikan bahwa ini membentuk pola 7-8-9, kita juga dapat melihat bahwa angka terakhir adalah 10 pada indeks 42. Dengan pertanyaan terakhir @Dennis tentang grup abelian , pemeriksaan cepat pada OEIS mengungkapkan bahwa 15, 22, 30, 42ini adalah urutan selanjutnya dari partisi angka . Pyth memiliki builtin untuk partisi, yang memberi kita dua dari delapan karakter:./

Tetapi perhatikan bahwa angka terakhir adalah 10, yang mencurigakan karena 10 adalah variabel preinitialised dalam Pyth, as T. ./Tmemberikan daftar lengkap dari 42 partisi nomor 10, yang sepertinya berguna.

Sekarang pencetakan dilakukan tanpa pemisah, jadi ini mengisyaratkan penggunaan p. Mungkin kita mengulang setiap partisi, melakukan sesuatu untuk itu, lalu mencetak dengan p? Ini memberi kami templat berikut:

V./Tp??N

Di mana Vadalah untuk loop yang loop atas iterable, menyimpan setiap elemen dalam variabel N.

Pandangan sekilas pada partisi terakhir kedua (5, 5)harus memperjelas bahwa kita ingin mengambil suatu produk. Cara naif untuk mengurangi daftar dengan perkalian adalah

u*GHd1

di mana ddaftar yang dimaksud. Namun, ini terlalu lama.

Sayangnya, di sinilah saya harus menarik forcer kasar. Saya tidak mengikuti Pyth untuk sementara waktu, jadi saya tidak tahu banyak fitur yang lebih baru. Hanya ada dua karakter yang tersisa, yang tampak sepenuhnya bisa dilakukan.

Forcer kasar kemudian kembali:

V./Tp*FN

dimana *Fdilipat oleh *(perkalian). Tidak heran saya tidak menemukannya dalam pencarian saya - saya mencari kata kunci "kurangi" daripada "lipat"!

Mathematica, alphalpha, ≤ 32

GroupOrder[MonsterGroupM[]]

Aku benci mengatakan ini, tapi aku baru saja mengenali nomornya di tempat.

> <>, VTCAKAVSMoACE, ≤ 64

'9?':?!;1-$:'@'+o'3'*'='%$30.

Ironisnya, ini tidak hanya jauh lebih rendah dari batas jangkauan, tetapi juga portabel dan bekerja dengan penerjemah online .

Analisis

Mari kita mulai dengan string target:

yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

> <> Dorongan karakter untuk stack dengan 'atau "dalam mode string, tapi dengan 63 karakter untuk mencetak dan hanya 64 byte untuk bekerja dengan, kehadiran huruf (petunjuk valid di> <>, untuk trik looparound standar) membuat pencetakan langsung mustahil. Karenanya, kita harus melakukan sesuatu dengan poin kode.

Konversi ke poin kode memberi (Saya menggunakan Python di sini):

>>> L = [ord(c) for c in "yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh["]
>>> L
[121, 104, 91, 99, 80, 87, 78, 107, 122, 94, 69, 75, 76, 66, 105, 81, 77, 117, 83, 118, 73, 96, 110, 92, 89, 119, 124, 74, 86, 88, 68, 85, 98, 90, 109, 102, 111, 82, 67, 95, 120, 114, 113, 123, 84, 108, 112, 72, 106, 71, 116, 93, 79, 97, 100, 70, 65, 115, 103, 101, 121, 104, 91]

Perhatikan bahwa tiga angka terakhir sama dengan tiga angka pertama. Ini mengisyaratkan kemungkinan loop modulo terjadi.

Mari kita lihat berapa banyak elemen berbeda yang kita miliki:

>>> len(set(L))
60

Kami memiliki 63 elemen L, tiga elemen pertama bertepatan dengan tiga elemen terakhir. Ini berarti bahwa, selain dari tabrakan ini, semua elemen lain adalah unik. Sekarang ini mengisyaratkan sesuatu seperti mengambil kekuatan modulo bilangan prima. Memang, 60 + 1 = 61adalah prima, yang merupakan pertanda baik.

Mari kita coba menemukan elemen terkecil

>>> min(L)
65

dan gunakan itu untuk mengurangi semua elemen sehingga elemen min adalah 1:

>>> M = [x-64 for x in L]
>>> M
[57, 40, 27, 35, 16, 23, 14, 43, 58, 30, 5, 11, 12, 2, 41, 17, 13, 53, 19, 54, 9, 32, 46, 28, 25, 55, 60, 10, 22, 24, 4, 21, 34, 26, 45, 38, 47, 18, 3, 31, 56, 50, 49, 59, 20, 44, 48, 8, 42, 7, 52, 29, 15, 33, 36, 6, 1, 51, 39, 37, 57, 40, 27]

Perhatikan bagaimana elemen setelah 1ini 51. Jika ada semacam kekuatan / perkalian yang terjadi, ini adalah tebakan yang bagus untuk pengganda kita.

Mari kita coba:

>>> (57*51)%61
40
>>> (40*51)%61
27
>>> all((x*51)%61 == y for x,y in zip(M, M[1:]))
True

Bingo! Kami sekarang dapat mundur, memberikan kode berikut:

x = 57
for _ in range(63):
    print(chr(x + 64), end="")
    x = (x*51)%61

yang kemudian diterjemahkan ke> <>

Pyth, Maltysen, ≤4

C.ZG

Brute force sangat lama sehingga saya melakukannya lebih cepat secara manual.

Analisis

C(convert string to base 256 int) adalah cara termudah untuk menghasilkan sejumlah besar dalam Pyth, jadi mungkin itu karakter pertama. Jika kami mengonversi dari basis 256, kami mendapatkan:

xÚKLJNIMKÏÈÌÊÎÉÍË/(,*.)-+¯¨¬ 

Hmm ... tidak terlalu mencerahkan.

Sekarang Gadalah string alfabet "abc...z", yang sepertinya bisa menjadi sumber untuk string panjang untuk dimasukkan C. Melihat melalui dokumen saya menemukan:

.Z    Compresses or decompresses a string.

Jika kita berurusan dengan kompresi di sini, tidak akan mengejutkan untuk mendapatkan semua jenis karakter ASCII yang diperluas. Mencoba C.ZGkemudian memberikan jawabannya.

Fourier, Beta Decay, ≤ 32

2~x1~y20(xoy~z*x~yz~xq^~q)

Atau sebagai alternatif, dalam CJam:

X0I{_2$+}*]2\f#

Analisis

Pada awalnya kita bisa melihat banyak kekuatan 2:

2
1
2
2
4
8
32
256
8192
2097152
...

Jika kita mengambil basis log 2 dari angka-angka ini, kita mendapatkan:

1 0 1 1 2 3 5 8 13 21 ...

yang merupakan seri Fibonacci, mulai dari 1, 0.

Siput, feersum, ≤2 byte

z

Ini sebenarnya 2 byte; karakter zdiikuti oleh baris baru \n.

Saya tidak tahu cara kerjanya atau apa yang dilakukannya, tetapi setelah menguji semua input yang mungkin terpisah dari ~+dan ~,, ini adalah satu-satunya program 2-byte yang dihasilkan 8sebagai output.

Dan butuh waktu lama untuk mendapatkan hasil ini. Tidak heran itu disebut "Siput" :-D

^{Catatan untuk diri sendiri: Lain kali Anda fuzz menguji perangkat lunak yang tidak dikenal, lakukan di dalam VM.}

Rust, Liam Noronha, ≤128 byte

fn main(){print!("AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO");}

Cukup mencetak string kata demi kata adalah 120 byte ...

Macaroni 0.0.2, Gagang Pintu, ≤64

set x "................................."print x print x print x

Python 2, Hapus pertanyaan dengan contoh, <= 64

Satu solusi yang mungkin:

print ''.join([" `{.~{{~||"[int(c)] for c in str(3**4278)])

( 9**2139, 27**1426dan 729**713juga memberikan hasil yang sama)

CoffeeScript, user2428118, ≤64

alert 0+(btoa k.substr -2 for k of document.body.style).join ''

(hanya berfungsi di Chrome 46.0.2490.71 seperti yang dijelaskan oleh Cop.)

Outputnya jelas merupakan rangkaian string pendek yang disandikan base64 karena semua "=". Setelah menguraikannya, kami menemukan daftar string 2-karakter seperti

['nt', 'ms', 'lf', 'ne', 'll', 'on', 'ay', 'on', …

yang sepertinya tidak masuk akal. Tapi saya menemukan beberapa barang aneh di dalamnya, seperti nXdan tY. Setelah menyaring ini kita dapatkan

>>> # Python
>>>
>>> [i for i in tt if not re.match('[a-z]{2}$', i)]
['nX', 'nY', 'tX', 'tY', 'wX', 'wY', 'r', 'nX', 'nY', 'tX', 'tY', 'nX', 'nY', 'nX', 'nY', 'nZ', 'x', 'y']

X dan Y ini tampaknya menunjukkan kode sumber asli yang digunakan seperti properti posisi offsetX/Y. Yang sangat menarik adalah nZitemnya. Untuk memeriksa asumsi saya, saya mencari semua properti yang diakhiri dengan "Z":

// CoffeeScript
checked = []
f = (o) ->
    if !(o in checked) 
        for k of o
            if /Z$/.test(k)
                console.log(o, k)
            if o[k] instanceof Object
                f o[k]
f window

yang menunjukkan banyak CSSStyleDeclaration, "webkitTransformOriginZ". Dari sini kami memiliki indikasi kuat bahwa daftar ini dibangun oleh 2 karakter terakhir dari semua kunci styleobjek, yang pengujian di atas menunjukkan memang benar.

Lua <= 4, Egor Skriptunoff

Banyak pengguna merasa gelisah tentang jawaban ini dalam obrolan, jadi saya harus membebaskan mereka dari kesengsaraan mereka. Saya tidak tahu Lua dan tidak bisa mengujinya, tetapi saya akan sangat terkejut jika ini tidak berhasil.

4^~9

Ini akan sangat jelas, tetapi mungkin tidak ada yang mendapatkannya karena operator bitwise hanya ditambahkan dalam versi 5.3; ideone.com hanya memiliki versi 5.2.

Python 2, histokrat, ≤16

[[[51002**3/6]]] 

Petunjuk terbesar adalah janji bahwa itu tidak akan berfungsi di Python 3. Apa yang berubah di Python 3 ? Tersangka terbesar adalah bahwa operator divisi mengembalikan a floatdalam Python 3.

Jadi saya berasumsi solusinya dalam bentuk ⌊α ^β / n⌋ = c = 22111101102001, karena eksponensial adalah satu-satunya cara pendek untuk membuat angka besar.

Jika {α, β, n} memang membentuk solusi, maka (cn) ^{1 / β} ≈ α harus sangat dekat dengan integer. Oleh karena itu saya menggunakan yang berikut untuk mencoba brute-force {α, β} untuk setiap n:

(* Mathematica *)
n=2; Sort[Table[{N[Abs[k - Round@k] /. k -> (22111101102001*n)^(1/b), 12], b}, {b, 2, 50}]]

(* Output: {{0.00262542213622, 7}, ...}

   The first number is the "quality" of the solution, lower is better.
   the second number is β.
   Thus α ≈ (nc)^(1/β) = 89
   But (89^7)/2 = 22115667447764, which is still far away from the answer.

*)

Hasil aktual dengan cepat keluar ketika n = 6.

MATLAB, StewieGriffin, ≤ 16

[36;87]*' |'*5

Cetakan:

ans =
        5760       22320
       13920       53940

Matlab, Luis Mendo, ≤16

Saya menemukannya, yay!

fix(peaks(9).^2)

Saya tidak tahu bahwa Oktaf juga bisa melakukan ini.

Mathematica, LegionMammal978, ≤64

Print@Nest[Compress,ExampleData[{"Text","ToBeOrNotToBe"}],13]

Python, spacemanjosh, ≤ 64

n=0;d=1;L=[]
exec("L+=[10/(100-n)**.5];n+=d;d+=2;"*10)
print(L)

Kalkulator simbolis terbalik yang mulia. Tidak bermain golf dengan baik, tapi hei itu cocok.

Sunting: Saya bermain golf.

print([10/(100-n*n)**.5for n in range(10)])

JavaScript ES6, Cᴏɴᴏʀ O'Bʀɪᴇɴ, ≤128 byte

var x=122,s='0037122342526683102122';for(var i=23;i<=505;i+=2)s+=(x+=i);s;

Saya ragu ini benar karena saya tidak perlu mendekati 128 byte, tetapi menemukan urutan berulang adalah tantangan yang menyenangkan.

Thue, ppperry, <= 64

0::=11
1::=22
2::=33
3::=44
4::=55
a::=bbb
b::=000
::=
aaaaaaa

Mengurai 2016 menjadi faktor utama, pada dasarnya. 62 karakter, jadi tebakan saya ini mirip dengan apa yang Anda tuju.

Python, DLosc, ≤32

(Solusi ini menggunakan Python 2)

a=97
while a<4e31:a^=a*2;print a

> <>, Sp3000, <= 8

'l(?; o>

Penunjuk instruksi membungkus dan langkah-langkah berikut terjadi:

• 'l(?; o>' mendorong nilai ASCII dari l(?; o> ke stack
• l mendorong ukuran tumpukan di tumpukan
• (bandingkan dua elemen tumpukan teratas: size of stackdanord('>')
• ?; menghentikan program jika ukuran tumpukan lebih besar
• o mengeluarkan elemen teratas dari stack sebagai karakter (ini akan selalu o )
• > set arah IP, ini dia no-op
• kita kembali ke langkah pertama

Output adalah oooooooooooo .

Kita bisa mendapatkan banyak output berbeda dengan mengubah [space]ke sesuatu yang mendorong atau muncul di stack dan menggunakan karakter lain yang valid sebagai gantinya >, yang juga dapat mendorong atau pop.

JavaScript, ev3commander, ≤ 32

console.log(0.1411200080598672)

Oke, itu mudah.

CJam, Reto Koradi, ≤ 4

HJK#

Tekan 17 , lalu 19 ²⁰ = 37589973457545958193355601 .

Cobalah online.

Hanya ada begitu banyak hal yang dapat Anda lakukan dalam empat byte. Suatu bilangan bulat sebesar ini harus melibatkan kekuatan atau faktorial, dan faktorial akan membuntuti nol.

Pyth <= 4, Dennis

ljyG

Itu panjang bergabung pada baris baru dari semua himpunan bagian dari alfabet.

Uji coba:

$ pyth -cd 'ljyG'
==================== 4 chars =====================
ljyG
==================================================
imp_print(Plen(join(subsets(G))))
==================================================
939524095

Saya menemukan nomor 2^27 * 7 - 1yang merupakan petunjuk kuat bahwa itu didasarkan yG, yang merupakan 2^26elemen panjang. Saya kemudian menebak itu harus dikonversi ke string dan panjangnya dicetak. Namun, satu-satunya cara untuk melakukan ini yang dapat saya pikirkan untuk sementara waktu adalah ``, repr. Kemudian saya memikirkan j, yang sangat cocok.

C, tucuxi, ≤64

main(i){for(i=0;i<11000;++i)if(!(i&2*i))printf("1%d",!(i&1));}

Outputnya semua 0 dan 1, tetapi C tidak dapat mencetak biner secara langsung, jadi sangat mungkin ini adalah hasil boolean.

Ada lebih dari 1s, jadi saya mencatat posisi 0s ( 3, 9, 13, 19, …), yang ternyata adalah OEIS A075318 . Ini tidak berguna, tidak ada rumus sederhana untuk menentukan di mana angka dalam urutan ini.

Tetapi kami mencatat bahwa ada semua angka ganjil, jadi mungkin (x-1)/2 = {1, 4, 6, 9, 12, …}ada informasi yang lebih berguna. Dan ini A003622 .

A003622 dapat didefinisikan sebagai "posisi 1 di A003849 ", yang persis apa yang perlu kita crack di sini. Dan A003849 didefinisikan sebagai " A003714 mod 2", di mana A003714 hanyalah semua bilangan bulat itu x & (2*x) == 0. Jadi kita sudah mendapat solusinya.

OEIS rox.

Dyalog APL, Dennis, ≤4

*⍨⍟8

Menghitung ln (8) ^ ln (8). Apakah StackExchange akan berhenti mengonversi jawaban saya? Saya akan mengetik banyak hal di sini sehingga tidak berubah menjadi komentar.

Terjebak, @quartata, ≤8

Program Pyth berikut :

^33 9

menghasilkan output yang diinginkan

46411484401953

Metode cracking: Pencarian Google untuk nomor tersebut.

Pyth, xnor, ≤ 4

C`CG

CG( "abc...z"Mengonversi string alfabet dari basis 256) adalah cara Pyth khas menghasilkan angka yang sangat besar. Setelah itu baru saja dirangkaikan dan dikonversi dari pangkalan lagi.

Python 3, Mego, ≤128

(Menggunakan Python 3.5.0, tidak diuji pada versi sebelumnya. 105 98 byte.)

import sys
a=sys.stdout
sys.stdout=None
from this import*
a.write(s.translate(s.maketrans(d))[4:])

Ruby, Gagang Pintu, ≤64

'@@'=~/(.)(.)/
p$~
test 0 rescue p"#$!@@".gsub //,$!.inspect+$/

Matlab / Oktaf, Wauzl, ≤16

"234"'*"567"

Menggunakan ide yang sama dengan jawaban Tom Carpenter

(Jika tidak berhasil, coba ini :)

[50;51;52]*'567'