Wątek gliniarzy można znaleźć tutaj: The Mystery String Printer (Cops)

Twoje wyzwanie

• Wybierz zgłoszenie z wątku gliniarzy i wydrukuj ciąg z odpowiedzi w tym wątku.
• Wybrane przez Ciebie zgłoszenie nie może być bezpieczne (musi być nowsze niż 7 dni).

• Twój program, funkcja lub skrypt REPL musi przestrzegać tych samych reguł, co wątek gliniarzy. Podsumowując:

  • Twój program musi mieć ≤ 128 znaków (jeśli przesłanie policjanta ma mniejszy zakres długości programu, twój program musi również mieć ten zakres długości. Na przykład, jeśli program policjanta ma ≤32 bajtów, twój program musi mieć ≤32 bajtów ).
  • Program musi generować to samo wyjście przy każdym uruchomieniu.
  • Brak funkcji kryptograficznych.
  • Program nie może pobierać danych wejściowych.
  • Brak standardowych luk.
• Wszystkie nowe zgłoszenia muszą używać tego samego języka. Zgłoszenia sprzed tej reguły są w porządku, nawet jeśli nie.

Punktacja

Punktacja działa podobnie dla złodziei, ale jest nieco inna:

• Złamanie dowolnego programu o wielkości ≤ 8 bajtów daje 1 punkt.
• Złamanie programu o wielkości 16 bajtów daje 2 punkty. ≤32 bajtów daje 4 punkty i tak dalej.
• Każde dodatkowe zgłoszenie, bez względu na długość, daje +5 punktów
• Zgłoszenie każdego gliniarza może zostać złamane tylko raz - tylko pierwsza osoba, która złamie każde zgłoszenie, otrzymuje punkty.

Zgłoszenia

Każda odpowiedź musi zawierać

• Link do zgłoszenia policjanta.
• Twój program i język programowania.
• Miej także długość programu policjanta (jako potęgę 2) jako ostatnią liczbę w nagłówku.

Dodatkowo proszę skomentować przesłanie policjanta z linkiem do swojej odpowiedzi.

Oto fragment kodu stosu do generowania tabel wyników. Zostaw komentarz, jeśli występuje problem z fragmentem kodu. Jeśli chcesz zobaczyć wszystkie otwarte zgłoszenia gliniarzy, zobacz fragment w wyzwaniu gliniarzy.

/* 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>

Ten konkurs jest teraz zamknięty.

Zwycięzca ogólny: kennytm

Większość zgłoszeń: Sp3000

(Uwaga: liczba zgłoszeń nie przekłada się dokładnie na punkty, ponieważ długość pękniętego programu jest liczona podczas obliczania wyniku).

Pyth, Dennis, ≤ 8

V./Tp*FN

Cholera, było fajnie - najtrudniej było wymyślić, jak to zrobić wystarczająco krótko w Pyth.

Analiza

1234Na podpowiedzi startowych że mamy prawdopodobnie do czynienia z listy numerów, drukowane bez separatora. Spróbujmy podzielić liczby w sposób, który ma sens:

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

Jest kilka wskazówek, że jesteśmy na dobrej drodze:

• Wszystkie liczby mają czynniki pierwsze mniejsze niż 10
• Wiele liczb jest bardzo zbliżonych do swojego indeksu na liście

Istnieje jednak kilka osobliwości. Liczba przy indeksie 23 wynosi 24 i jest to jedyny przypadek, w którym liczba przy indeksie jest większa niż sam indeks. Jednak większą wskazówką jest to, że niektóre liczby są wyraźnie mniejsze niż ich sąsiedzi, szczególnie 7 przy indeksie 15, 8 przy indeksie 22 i 9 przy indeksie 30.

Zauważając, że tworzy to wzór 7-8-9, możemy również zobaczyć, że ostatnia liczba to 10 przy indeksie 42. Biorąc pod uwagę ostatnie pytanie @Dennis dotyczące grup abelowych , szybkie sprawdzenie OEIS ujawnia, że 15, 22, 30, 42jest to podsekwencja podziału numery . Pyth ma wbudowane partycje, które dają nam dwa z ośmiu znaków:./

Ale zauważ, że ostatnia liczba to 10, co jest podejrzane, ponieważ 10 jest zmienną wstępnie zainicjalizowaną w Pyth, as T. ./Tdaje pełną listę 42 partycji liczby 10, co wygląda na to, że może się przydać.

Teraz drukowanie odbywa się bez separatora, więc to wskazuje na użycie p. Być może przeglądamy każdą partycję, coś z tym robimy, a następnie drukujemy p? To daje nam następujący szablon:

V./Tp??N

gdzie Vjest pętla for, która zapętla się nad iterowalnym, przechowując każdy element w zmiennej N.

Szybkie spojrzenie na drugą ostatnią partycję (5, 5)powinno dać jasno do zrozumienia, że ​​chcemy wziąć produkt. Naiwnym sposobem zmniejszenia listy przez pomnożenie jest

u*GHd1

gdzie djest lista, o której mowa. To jednak zdecydowanie za długo.

Niestety właśnie tutaj musiałem wyciągnąć brutalnego forcera. Przez jakiś czas nie nadążałem za Pyth, więc nie znałem wielu nowszych funkcji. Pozostały tylko dwie postacie, które wyglądały na wykonalne.

Brutalny forcer następnie wrócił:

V./Tp*FN

gdzie *Fjest fold by *(mnożenie). Nic dziwnego, że nie znalazłem go podczas wyszukiwania - szukałem słowa kluczowego „zmniejsz” zamiast „pasuj”!

Mathematica, alfa, ≤ 32

GroupOrder[MonsterGroupM[]]

Nienawidzę tego mówić, ale właśnie rozpoznałem numer na miejscu.

> <>, VTCAKAVSMoACE, ≤ 64

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

Jak na ironię, nie tylko jest to znacznie niższy limit zasięgu, ale także jest przenośny i współpracuje z tłumaczem online .

Analiza

Zacznijmy od ciągu docelowego:

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

> <> wypycha znaki do stosu za pomocą 'lub "w trybie łańcuchowym, ale przy 63 znakach do wydrukowania i tylko 64 bajtach do pracy, obecność wielkich liter (nieprawidłowe instrukcje w> <>, dla standardowej sztuczki z pętlą) powoduje bezpośrednie drukowanie niemożliwy. Dlatego musimy coś robić z punktami kodowymi.

Konwersja na punkty kodowe daje (używam tutaj Pythona):

>>> 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]

Zauważ, że ostatnie trzy liczby są takie same jak pierwsze trzy. Wskazuje to na możliwą pętlę modulo.

Zobaczmy, ile mamy różnych elementów:

>>> len(set(L))
60

Mamy 63 elementy L, z których pierwsze trzy pokrywają się z trzema ostatnimi. Oznacza to, że oprócz tego zderzenia wszystkie inne elementy są unikalne. To sugeruje coś w rodzaju przejęcia modulo mocy liczby pierwszej. Rzeczywiście, 60 + 1 = 61jest liczbą pierwszą, co jest dobrym znakiem.

Spróbujmy znaleźć najmniejszy element

>>> min(L)
65

i użyj tego, aby przeskalować wszystkie elementy w dół, tak aby element min wynosił 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]

Zwróć uwagę, jak element po 1to 51. Jeśli dzieje się coś w rodzaju mocy / mnożenia, jest to dobre przypuszczenie dla naszego mnożnika.

Spróbujmy:

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

Bingo! Możemy teraz cofnąć się, podając następujący kod:

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

który został następnie przetłumaczony na> <>

Pyth, Maltysen, ≤4

C.ZG

Brutalna siła trwała tak długo, że robiłem to szybciej ręcznie.

Analiza

C(konwersja łańcucha na podstawową liczbę int 256) jest najprostszym sposobem na wygenerowanie dużej liczby w Pyth, więc prawdopodobnie jest to pierwszy znak. Jeśli dokonamy konwersji z bazy 256, otrzymamy:

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

Hmm ... niezbyt pouczające.

Teraz Gjest ciąg alfabetu "abc...z", który wygląda na to, że może być źródłem długiego ciągu, do którego można się zasilać C. Przeglądając dokumenty, znajduję:

.Z    Compresses or decompresses a string.

Jeśli mamy do czynienia z kompresją, nie byłoby zaskoczeniem, aby uzyskać wszelkiego rodzaju rozszerzone znaki ASCII. Próbując C.ZGnastępnie dał odpowiedź.

Fourier, rozpad beta, ≤ 32

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

Lub alternatywnie w CJam:

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

Analiza

Na początku możemy zobaczyć wiele potęg 2:

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

Jeśli weźmiemy log 2 jako podstawę tych liczb, otrzymamy:

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

która jest serią Fibonacciego, zaczynając od 1, 0.

Ślimaki, feersum, ≤ 2 bajty

z

To w rzeczywistości 2 bajty; znak, zpo którym następuje nowa linia \n.

Nie mam pojęcia, jak to działa ani co robi, ale po przetestowaniu wszystkich możliwych danych wejściowych oprócz ~+i ~,był to jedyny 2-bajtowy program, który został wygenerowany 8jako dane wyjściowe.

Zdobycie tego wyniku zajęło wieki . Nic dziwnego, że nazywa się to „Ślimaki” :-D

^{Uwaga do siebie: przy następnym fuzzowaniu nieznanego oprogramowania zrób to w maszynie wirtualnej.}

Rdza, Liam Noronha, ≤ 128 bajtów

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

Zwykłe wydrukowanie napisu ciągłego to 120 bajtów ...

Macaroni 0.0.2, Klamka, ≤64

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

Python 2, Wyczyść pytanie z przykładami, <= 64

Jedno możliwe rozwiązanie:

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

( 9**2139, 27**1426a 729**713także dać ten sam wynik)

CoffeeScript, użytkownik2428118, ≤64

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

(działa tylko w Chrome 46.0.2490.71 zgodnie z opisem Cop.)

Wynik jest oczywiście połączeniem krótkich łańcuchów kodowanych base64 ze względu na wszystkie „=”. Po ich zdekodowaniu znajdujemy listę 2-znakowych ciągów takich jak

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

co nie wydaje się mieć sensu. Ale znajduję w nim dziwne przedmioty, takie jak nXi tY. Po ich odfiltrowaniu otrzymujemy

>>> # 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']

Te X i Y wydają się wskazywać na pierwotny kod pozycji wykorzystujący właściwości pozycji, takie jak offsetX/Y. Szczególnie interesujący jest nZprzedmiot. Aby sprawdzić moje założenie, szukałem wszystkich właściwości, które kończą się na „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

który pokazuje mnóstwo CSSStyleDeclaration, "webkitTransformOriginZ". Z tego mamy wyraźne wskazanie, że lista składa się z 2 ostatnich znaków wszystkich kluczy styleobiektu, co pokazuje powyższy test.

Lua <= 4, Egor Skriptunoff

Wielu użytkowników denerwowało się tą odpowiedzią na czacie, więc muszę uwolnić ich od nędzy. Nie znam Lui i nie mogłem tego przetestować, ale byłbym bardzo zaskoczony, gdyby to nie zadziałało.

4^~9

Byłoby to dość oczywiste, ale prawdopodobnie nikt tego nie zrozumiał, ponieważ operatory bitowe zostały dodane tylko w wersji 5.3; ideone.com ma tylko wersję 5.2.

Python 2, histocrat, ≤16

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

Największą wskazówką jest obietnica, że ​​nie będzie działać w Pythonie 3. Co zmieniło się w Pythonie 3 ? Największym podejrzanym jest to, że operator podziału zwraca a floatw Pythonie 3.

Zakładam więc, że rozwiązanie ma postać ⌊α ^β / n⌋ = c = 22111101102001, ponieważ potęgowanie jest jedyną krótką drogą do tworzenia wielkich liczb.

Jeśli {α, β, n} rzeczywiście tworzy rozwiązanie, to (cn) ^{1 / β} ≈ α powinno być bardzo zbliżone do liczby całkowitej. Dlatego używam następującego, aby spróbować użyć siły {α, β} dla każdego 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.

*)

Rzeczywisty wynik szybko wychodzi, gdy n = 6.

MATLAB, StewieGriffin, ≤ 16

[36;87]*' |'*5

Wydruki:

ans =
        5760       22320
       13920       53940

Matlab, Luis Mendo, ≤16

Znalazłem to, tak!

fix(peaks(9).^2)

Nie wiedziałem, że Octave też może to zrobić.

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)

Chwalebny odwrotny symboliczny kalkulator. Nie za dobrze gra w golfa, ale hej, pasuje.

Edycja: Grałem w golfa.

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

JavaScript ES6, Cᴏɴᴏʀ O'Bʀɪᴇɴ, ≤128 bajtów

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

Wątpię, żeby było dokładnie tak, ponieważ nie potrzebowałem prawie 128 bajtów, ale znalezienie powtarzającej się sekwencji było fajnym wyzwaniem.

Wt, ppperry, <= 64

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

Zasadniczo rozkłada 2016 na czynniki pierwsze. 62 znaków, więc przypuszczam, że jest to podobne do tego, co chciałeś.

Python, DLosc, ≤32

(To rozwiązanie wykorzystuje Python 2)

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

> <>, Sp3000, <= 8

'l(?; o>

Wskaźnik instrukcji zawija się i następują następujące kroki:

• 'l(?; o>'wypycha wartości ASCII l(?; o>na stos
• l przesuwa rozmiar stosu na stosie
• (porównaj dwa górne elementy stosu: size of stackiord('>')
• ?; zatrzymuje program, jeśli rozmiar stosu był większy
• owypisuje górny element stosu jako znak (będzie to zawsze o)
• > ustawia kierunek IP, tutaj nie ma opcji
• wracamy do pierwszego kroku

Dane wyjściowe to oooooooooooo.

Możemy uzyskać wiele różnych wyników, zmieniając [space]na coś, co popycha lub wyskakuje na stosie i używając innego ważnego znaku zamiast >, który może również popychać lub pop.

JavaScript, ev3commander, ≤ 32

console.log(0.1411200080598672)

OK, to było łatwe.

CJam, Reto Koradi, ≤ 4

HJK#

Popycha 17 , a następnie 19 ²⁰ = 37589973457545958193355601 .

Wypróbuj online.

Jest tylko tyle rzeczy, które możesz zrobić w czterech bajtach. Tak duża liczba musiała w jakiś sposób obejmować moce lub silnie, a silnia miałaby końcowe zera.

Pyth <= 4, Dennis

ljyG

To długość łączenia na nowych liniach wszystkich podzbiorów alfabetu.

Testowe uruchomienie:

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

Doszedłem do wniosku, że liczba 2^27 * 7 - 1jest silną wskazówką, na której się opiera yG, która jest 2^26długa. Wtedy domyśliłem się, że trzeba go przekonwertować na sznurek i wydrukować jego długość. Jednak jedynym sposobem na zrobienie tego, o czym mogłem pomyśleć, był ``, repr. Potem pomyślałem o tym j, co idealnie pasuje.

C, tucuxi, ≤64

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

Dane wyjściowe to 0 i 1, ale C nie może wydrukować pliku binarnego bezpośrednio, więc jest bardzo prawdopodobne, że są to wyniki logiczne.

Jest więcej niż 1 zera, więc zapisałem pozycje 0s ( 3, 9, 13, 19, …), co okazuje się być OEIS A075318 . Nie jest to jednak przydatne, nie ma prostej formuły określającej, gdzie jest liczba w tej sekwencji.

Ale zauważamy, że wszystkie liczby nieparzyste są, więc być może (x-1)/2 = {1, 4, 6, 9, 12, …}mają bardziej przydatne informacje. A to jest A003622 .

A003622 można zdefiniować jako „pozycje 1 w A003849 ”, i właśnie to musimy tutaj złamać. A A003849 jest zdefiniowany jako „ A003714 mod 2”, gdzie A003714 to po prostu wszystkie liczby całkowite x & (2*x) == 0. Tak więc mamy rozwiązanie.

OEIS rox.

Dyalog APL, Dennis, ≤4

*⍨⍟8

Oblicza ln (8) ^ ln (8). Czy StackExchange przestanie konwertować moje odpowiedzi? Napiszę tu kilka rzeczy, żeby nie zamieniły się w komentarz.

Stuck, @ quartata, ≤8

Następujący program w języku Pyth :

^33 9

produkuje pożądaną moc wyjściową

46411484401953

Metoda pękania: przeszukałem numer Google.

Pyth, xnor, ≤ 4

C`CG

CG(konwersja ciągu alfabetu "abc...z"z bazy 256) jest typowym sposobem Pyth'a na generowanie naprawdę dużej liczby. Po tym to po prostu skreślić i przekonwertować z bazy ponownie.

Python 3, Mego, ≤128

(Przy użyciu Python 3.5.0, nie testowany na poprzednich wersjach. 105 98 bajtów.)

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

Rubin, Klamka, ≤64

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

Matlab / Octave, Wauzl, ≤16

"234"'*"567"

Korzystając z tego samego pomysłu, co odpowiedź Toma Carpentera

(Jeśli to nie zadziałało, spróbuj tego :)

[50;51;52]*'567'