Decodifica il codice sorgente [thread del ladro per tentativi di cracking]

44

Questo è il filo conduttore della sfida principale di Decodificare il codice sorgente . Se pensi di essere riuscito a decodificare una delle risposte del poliziotto, dovresti pubblicare la tua soluzione come risposta a questa discussione.

Come promemoria, hai un tentativo di decifrare ogni invio. Il tuo tentativo di cracking sarà una versione decodificata del codice sorgente. Se la tua ipotesi corrisponde alla descrizione (stessi caratteri, output e ovviamente lingua) e sei la prima ipotesi corretta, allora vinci un punto. È importante notare che il programma non deve corrispondere esattamente all'originale, utilizzare semplicemente gli stessi caratteri e avere le stesse funzionalità. Ciò significa che potrebbe esserci più di una risposta corretta.

Vince il ladro con il maggior numero di punti (incrinature riuscite).

Classifica

Troppe soluzioni

20 soluzioni

15 soluzioni

10 soluzioni

7 risolve

5 soluzioni

4 risolve

3 soluzioni

2 risolve

1 risolvere

cops-and-robbers 
— PhiNotPi
fonte
1
Perl 5, misura 27, di Morot - print'pin '= ~ tr (a-za) (za-z) r
@ WumpusQ.Wumbley Siamo stati tutti lì ...;)
— Martin Ender
3
Mi rifiuto di sprecare il mio tempo nel tentativo di placarlo.
Dati i due gruppi di domande, sembra che le risposte criptate / non criptate siano invertite
— Mooing Duck
Ruby, 23 di MegaTom = p% ++. Metodi [80] [1 ..- 1]
— histocrat

Risposte:

32

CJam, taglia 20, di Martin Büttner

Hi "petStorm!", mame

Provalo online.

Come funziona

Hi                      "           int(17)                     ";
   "petStorm!",         "                    len('petStorm!')   ";
                ma      "     atan2(       ,                 )  ";
                  me    " exp(                                ) ";
                        " exp(atan2(int(17), len('petStorm!'))) ";

Craccare il codice

L'output desiderato 2.956177636986737è un doppio o un doppio seguito da un lungo.

Usando solo i caratteri in "Stop, Hammer time!", ci sono quattro operatori integrati che restituiscono doppi non interi:

  • mS, che è asin
  • ma, che è atan2
  • me, che è exp
  • mt, che è tan

Tutti contengono un m, quindi possiamo usarne al massimo tre. C'è solo uno Se uno a.

Tutti questi operatori hanno bisogno di input ed maè l'unico che consuma due input. Abbiamo solo tre modi per spingere Longs:

  • "...",, che spinge la lunghezza della stringa (rigorosamente inferiore a 18).
  • H, che spinge 17.
  • ...!, che spinge il NOT logico di ....

Non abbiamo modo di spingere qualcosa di falso come ..., quindi l'ultima opzione spingerà sempre 0.

L'output non inizia o termina con 17o 0. Dal momento che 15 cifre decimali sono il solito numero di cifre per un doppio, sembrava probabile che l'output fosse un doppio semplice.

Supponendo ciò, il codice deve rientrare in una delle seguenti categorie:

  • <Long> <mS|me|mt>{1,3}
  • <Long> <mS|me|mt>{x} <Long> <mS|me|mt>{y} ma <mS|me|mt>{z}.
  • Uno dei precedenti, con qualche cast su Long ( i) o rounding ( mo) applicato a un Double.

Nel secondo caso, x + y + zè 1 o 2 e uno dei Long è 0 o 17.

Il resto era fondamentalmente forza bruta. Dopo qualche tentativo,

18 , {H \ ma me 2.956177636986737 =} =

restituito 9, nel senso che

H 9 ma me

produce l'output desiderato.

Non resta che eliminare tutti i caratteri tranne 9 dalla stringa. Gli spazi sono noops ed iè un noop su Longs, quindi "petStorm!"è una delle possibili scelte.

— Dennis
fonte
1
È folle: come hai capito qual era il numero?
— Sp3000,
1
Ho cercato il logaritmo (e altri) di quel numero ma non ho ottenuto alcun risultato. Ora ho scoperto che stavo usando una precisione troppo elevata.
— jimmy23013,
2
@ Sp3000: ho modificato la mia risposta.
— Dennis,
1
Molto bella! Avrei dovuto estrarre altri due caratteri dalla stringa immagino. Nel mio originale avevo effettivamente gli spazi ancora all'interno della stringa, ma mrprima di prendere la lunghezza. Non che non lo avresti capito anche a un certo punto. ;)
— Martin Ender,
25

Python 3, misura 12, di xnor

()and bciprt

Non fa nulla (l'espressione produce una tupla vuota, che non viene stampata). Questo funziona a causa della valutazione del corto circuito.

— matsjoyce
fonte
1
In Python 3 IDLE, questo genera ().
— Hosch250,
@ hosch250 Dato che si trova in un programma (un file Python), non viene emesso nulla, in quanto non esiste print.
— matsjoyce,
Vedo. Stavo correndo dalla cosa della riga di comando.
— Hosch250,
47
.... "cosa" ....
— TheDoctor
4
@Imray A causa del cortocircuito - Python carica la tupla e verifica se il valore della tupla è vero, poiché è vuoto, è falso. Il codice per caricare la variabile bciprtnon viene mai eseguito, quindi non produce mai un NameError.
— Mateon1,
20

Python, taglia 74, di xnor

any(print(set is
set)for i in oct(chr is
map))and aeeeeeggiilnnpprrrrrstvw

Beh, è ​​stato divertente. Grazie a FryAmTheEggman, hosch250 e isaacg per suggerimenti / aiuto.

— SP3000
fonte
1
Bel lavoro! La mia soluzione era abbastanza simile: list(\nprint(range is range)for aacdeeeeehmppprrrrssvwy in\noct(int is int)).
— xnor
@xnor LOL quel nome di variabile. È un peccato che non ci avrei mai pensato? : P
— FryAmTheEggman,
2
@FryAmTheEggman Penso che tutti si aspettassero che usassi il trucco del mio primo poliziotto .
— xnor
@FryAmTheEggman Non ti preoccupare, non sei l'unico: P
— Sp3000,
13

Python 2, taglia 50, di Geobits

print 2**2**2*2**2-22-2**2**2**2/2**2**2**2**2/2/2

Uscite 42.

— Ypnypn
fonte
1
Avere un punto :) Per riferimento, l'originale era print 2**2**2**2/2**2**2/2**2**2/2-2**2**2*2**2-22, ma non sorprende affatto che più di un'opzione sia corretta.
— Geobits il
13

GolfScript, taglia 13, di Peter Taylor

,22,{.4&?+.}/

Provalo qui.

Un altro, che ho risolto solo con il grande aiuto di Sp3000. Grazie!

Quindi ecco come ci siamo arrivati. Sp3000 ha notato un sacco di serie di numeri consecutivi nell'output:

1,2,3,4,[2608852181],4582,4583,4584,4585,4586,[253225388392299],
142924,142925,142926,142927,142928,[302928],497409,497409

Sulla base di ciò abbiamo ipotizzato che si trattasse di una sequenza crescente, che consentiva solo una possibile suddivisione dei numeri rimanenti:

1,2,3,4,260,885,2181,4582,4583,4584,4585,4586,25322,53883,92299,
142924,142925,142926,142927,142928,302928,497409,497409

Sono 23 numeri, che erano un forte indicatore per ripetere il blocco 22 volte, oltre a terminare il blocco con .(elemento duplicato in cima allo stack), in modo tale che il risultato precedente fosse lasciato indietro nello stack e tale che l'iterazione finale sarebbe apparsa su la pila due volte. Questo è 22,{____.}/.

Ora osservando le lacune, quelle risultano essere i 4 poteri (il che è bello, perché abbiamo 4e ?). Più precisamente, sono la quarta potenza dell'indice del numero corrente. Quindi abbiamo esaminato quali indici hanno creato un gap:

4,5,6,7, 12,13,14,15, 20,21,..?

In binario quelli sono

00100
00101
00110
00111
01100
01101
01110
01111
10100
10101

Tutti hanno il terzo bit impostato, il che significa che l'indice è probabilmente solo bit a bit e con 4(che è di nuovo bello, perché possiamo fare un altro 4con .e avere un &). Funziona particolarmente bene, perché questa operazione si traduce in uno 0o 4, e se lo usiamo come esponente otteniamo uno 1o un quarto potere, che è esattamente ciò di cui abbiamo bisogno. Quindi mettiamolo insieme:

22,{.4&?+.}/

Ecco cosa fa il blocco:

.      # Duplicate current index
 4     # Push a 4
  &    # Bitwise and
   ?   # Raise index to resulting power
    +  # Add to previous result
     . # Duplicate for use in next iteration

Ora c'erano ancora due problemi: avevamo un randagio ,che non usavamo ancora, e la prima iterazione è un caso speciale, in quanto non vi è alcun valore da una precedente iterazione a cui potremmo aggiungere cose quando ci incontriamo +. Abbiamo scoperto che grazie a un commento non correlato dell'utente23013 che ha citato casualmente che GolfScript inizia con una stringa vuota nello stack (se non c'è nulla su STDIN). Quindi potremmo usare quell'altro ,diritto all'inizio per trasformare quella stringa in a 0, che era proprio quello di cui avevamo bisogno come inizio dell'iterazione.

— Martin Ender
fonte
Spot on. Questo è stato ispirato da una sequenza in OEIS che non riesco a trovare ora.
— Peter Taylor,
3
Ed è per questo che avere una discussione separata per i ladri è una buona idea. Bel lavoro!
— Dennis,
11

Rubino, misura 17, di Doorknob

p 2,%r~n~i=~'*tN'

È stato molto divertente. Grazie a Sp3000 per avermi aiutato con questo! E ho imparato che i %r?...?letterali possono avere delimitatori. :)

— Martin Ender
fonte
10
Puntelli a Doorknob per essere follemente fuorviante print, solo per dividerlo in pper la stampa, %rper le regex e iper la corrispondenza dei regex senza distinzione tra maiuscole e minuscole.
— Sp3000,
11

PHP, taglia 49, di bwoebi

print@substr(new exception,+~$$a+=++$$m+$$i+2+n);

È stato assolutamente mentale .

Ci siamo riusciti

print@substr(new exception,);

abbastanza rapidamente, a quel punto avevo bisogno di qualcosa che dia -6dopo la virgola, dopo aver $++$++$++$+=$~main$2lasciato.

Il problema principale è che $a, $me lo $isono tutti NULL, quindi usandoli indirettamente in variabili variabili , significa che puntano tutti alla stessa variabile. Tuttavia, PHP sembra fare alcune cose strane sulla risoluzione delle variabili variabili. Con variabili normali puoi fare cose del genere

echo $a+$a=2;

quale stampa 4(il 2viene assegnato a $ae quindi aggiunto a se stesso). Ma se faccio lo stesso con le variabili variabili:

echo $$a+$$a=2;

Capisco 2, perché ora il primo $$aè valutare prima dell'incarico.

Alla fine sono riuscito a forzare un po 'di ordine mettendo alcuni incrementi sull'RHS del +=quale dovevano essere valutati prima di quell'assegnazione di addizione. In quel modo sono arrivato a 5cui avrei potuto semplicemente completare un po '. Tuttavia ... ci sono alcune cose misteriose in corso, e non ho idea del perché metà delle cose che ho provato ha funzionato e non ha funzionato.

— Martin Ender
fonte
Per riferimento, il mio originale:print@substr(new exception,~$$mn+=2+$$a+++$$i++);
— bwoebi,
Btw. Spero che tutti i segni del dollaro e il fatto che tutte le lettere per mainfossero nella stringa ti inducano molto in errore. Inoltre, {main}penso che sia un metodo piuttosto insolito per l'estrazione ;-)
— bwoebi,
@bwoebi The mainnon mi ha davvero fuorviato , dopo aver individuato exception, newe substr. Ho pensato che sarebbero stati solo nomi di variabili. Mi ci è voluto un po 'per inventare l'uso di variabili variabili e poi ho trascorso la maggior parte del tempo a capire un ordine di operazioni che avrebbe effettivamente prodotto un risultato 5che avrei potuto integrare senza usare un'altra serie di parentesi.
— Martin Ender,
Bene, per la prossima volta, se ci sono più dollari che caratteri, di solito sono variabili variabili. (In questo caso ho anche abusato di varvars per forzare la valutazione da sinistra a destra.) Quanto tempo hai impiegato allora a individuare la nuova eccezione del substr? Inoltre, ho una conoscenza più approfondita del motore Zend, quindi posso spiegarmi perfettamente perché le cose vengono valutate in quale ordine ed è bello per queste sfide ;-) Se c'è una cosa specifica che non ottieni, io ' Te lo spiegherò felicemente.
— bwoebi,
@bwoebi Vieni in chat domani, e possiamo parlarne, ma oggi ho trascorso abbastanza tempo. ;) Per quanto riguarda la tua prima domanda, exceptionera ovvio, che ha lasciato personaggi vaganti substre newin giro. È stata letteralmente la prima cosa che ho visto quando ho iniziato a lavorarci.
— Martin Ender,
9

Rubino, taglia 38, di Doorknob

[$><<(!$pece60).to_s[rand($win)].succ]

Sono abbastanza sicuro che questo non sia affatto vicino alla fonte originale. È deterministico nonostante l'utilizzo rand.

Ecco come funziona. $><<è solo in uscita. $pece60e $winsono variabili globali indefinite, che quindi sono giuste nil(e mi hanno permesso di liberarmi di alcuni caratteri estranei). !$pece60crea un truee to_sdà la stringa "true".

Per anni, ho provato a ottenere un 2o -2per accedervi ulì, ma poi ho capito che potevo semplicemente prendere il t, e chiamare .succ(essor) su di esso per fare un u.

randcon un nilparametro restituisce un float casuale nell'intervallo [0,1). Quando si usano i float per indicizzare in stringhe, vengono troncati in numeri interi, quindi questo restituirà sempre il primo carattere.

Alla fine, ne avevo una coppia di riserva, []quindi ho appena avvolto tutto, perché per fortuna tutto è un'espressione in Ruby.

Grazie a Sp3000 per aver lanciato alcune idee in chat.

— Martin Ender
fonte
8
Ruby è un linguaggio dall'aspetto spaventoso.
— febbraio
8

C, 51 di es1024

c=0xf.cp9,hhtaglfor;main() {;; printf("%d",(++c));}

Dopo 20 anni di programmazione C oggi ho imparato a conoscere le costanti in virgola mobile esadecimali.

— Arte
fonte
8

Ruby, 45 (istocratico)

%q[zyfnhvjkwudebgmaclprs x].to_i(36)/51074892

Woohoo! Questa è la mia prima crepa in un problema di codice golf e non ho abbastanza rappresentante per commentare il post originale. Ho immediatamente riconosciuto il trucco usato, dal momento che in realtà l'ho trovato spesso usato nel codice di produzione. Ci sono voluti circa 5 minuti per capire la maggior parte della struttura e alcune ore per trovare la risposta completa.

Spiegazione:

  • %q[]è un metodo alternativo per creare stringhe. È possibile utilizzare anche parentesi e parentesi graffe.
  • String#to_i in Ruby accetta numeri in qualsiasi base da 2 a 36. Ignorerà il primo carattere nella stringa che non fa parte del numero, quindi eventuali caratteri aggiuntivi possono essere "gettati via" dopo lo spazio.

Ed ecco il codice che ho usato per decifrarlo:

require 'set'

# return true if the string is made up of unique characters
def uniq(s)
  a = s.each_char.to_a
  return a == a.uniq
end

def uniq_while_same(a,b)
  s = Set.new
  a.each_char.zip(b.each_char).each do |ai, bi|
    return true if ai != bi
    return false if s.include? ai
    s << ai
  end
  return true
end

def ungolf(answer)
  # For each base that even makes sense
  [            36, 35, 34,     32, 31, 30,
   29, 28, 27, 26, 25, 24, 23,     21, 20,
   19, 18, 17, 16, 15, 14, 13, 12,     10].each do |base|
    # Ignore bases where it is not possible to create a unique-string number greater than answer
    next if answer > base ** base
    # Pick digits for the denominator that are not duplicates of the digits in base
    denominator_digits = ('1234567890'.each_char.to_a - base.to_s.each_char.to_a)
    # For each permutation of those digits for the denominator
    (1..10).each do |denominator_length|
      denominator_digits.permutation(denominator_length) do |denominator_s|
        # Maybe the denominator is in octal
        denominator_base = 10
        if denominator_s[0] == '0'
          next if denominator_s.include?('8') || denominator_s.include?('9')
          denominator_base = 8
        end
        denominator_s = denominator_s.join
        denominator = denominator_s.to_i denominator_base
        print "#{"\b"*64}(%q[#{(answer * denominator).to_s(base).ljust(36)}].to_i #{base})/#{denominator_s.ljust(10)}" if rand < 0.01
        # Ignore denominators that are definitely impossible to have answers for
        next unless uniq_while_same "qtoi#{base}#{denominator_s}#{(answer * denominator).to_s(base)}",
                                    "qtoi#{base}#{denominator_s}#{((answer + 1) * denominator).to_s(base)}"

        # For each numerator that gives answer when divided by the denominator
        (answer * denominator...(answer + 1) * denominator).each do |numerator|
          print "#{"\b"*64}%q[#{numerator.to_s(base).ljust(36)}].to_i(#{base})/#{denominator_s.ljust(10)}" if rand < 0.01
          # Remove any that are still not unique
          s = "#{numerator.to_s(base)}#{base}#{denominator_s}qtoi"
          next unless uniq s
          # Done. Compute which characters need to be thrown away to fill the remaining space
          remains = ('0123456789abcdefghijklmnopqrstuvwxyz'.each_char.to_a - s.each_char.to_a).join
          print "#{"\b"*64}#{" "*64}#{"\b"*64}"
          return "%q[#{numerator.to_s(base)} #{remains}].to_i(#{base})/#{denominator_s}"
        end
      end
    end
  end
  print "#{"\b"*64}"
  puts "\nnone"
  return nil
end


print ungolf 9410663329978946297999932

Modo per incorporare un problema NP all'interno di un indovinello. Sono stato completamente secchiato. Buon lavoro!

— charredUtensil
fonte
Ho aggiunto un commento alla risposta originale per te.
— FireFly
Questo è fantastico (e vicino alla risposta prevista), ma tecnicamente non valido perché non ha output.
— istocratico
* facepalm Beh, mi sono ancora divertito.
— CharredUtensil
2
@charredUtensil se non ti dispiace eseguire la tua sceneggiatura per un po 'di più, penso che la stampa stia semplicemente spostando la pprima dell'espressione. Presumibilmente i caratteri rimanenti possono essere usati per formare le costanti come hai fatto.
— FireFly
In realtà non ho bisogno di eseguirlo di nuovo. Gli ultimi caratteri della stringa possono essere riorganizzati senza cambiare il risultato - p %q[zyfnhvjkwudebgmaclrsx].to_i(36)/51074892so che ho rotto il mio vero tentativo di cracking :)
— charredUtensil
7

CJam, taglia 13, dall'utente23013

G,Cf#If/sE*K%

Provalo qui.

Risolto a mano, in questo modo:

Innanzitutto, alcuni retroscena per i non CJammer:

  • CEGIKsono tutte variabili che vengono pre-inizializzati a 12, 14, 16, 18, 20, rispettivamente.
  • s converte l'elemento stack superiore in una stringa.
  • Le stringhe sono tecnicamente solo matrici di caratteri.
  • fè piuttosto magico. Ai fini di questa risposta, la versione semplificata è che, per una matrice a, un altro valore be un operatore g, la sequenza abfgmappe g(_,b)su a(dove ogni elemento aentra nella _fessura).
  • / è la divisione e la divisione di matrici (tra le altre cose).
  • * è la moltiplicazione e la ripetizione di array (tra le altre cose).
  • %è modulo e alcune strane operazioni, che nella forma ad%per array ae interi daccetta ogni delemento th a(come lo slicing di Python con larghezza del passo d).
  • # è esponenziazione (tra le altre cose).
  • ,trasforma i numeri in intervalli (da 0a n-1) e restituisce la lunghezza di un array.

Va bene, quello fuori mano ...

Era abbastanza ovvio che dovevamo ,trasformare un numero in un intervallo, perché l'unico altro modo per ottenere un array sarebbe stato quello di costruire un numero più grande e trasformarlo in un array di caratteri con s- ma poi non avremmo potuto fare ulteriore aritmetica su di esso. E abbiamo bisogno di un array per fare qualcosa con la fs.

Per prima cosa ho pensato che le fs fossero usate con #e %, ma ciò significherebbe che avremmo avuto bisogno di un numero di circa 90 per ottenere la giusta quantità di cifre alla fine. Inoltre, questo non ha spiegato cosa farsene s, e dato che la risposta sembrava davvero impertinente, ho dubitato che l'utente23013 abbia semplicemente aggiunto una sno-op efficace da qualche parte per allontanare la gente.

Quindi ho pensato, forse non sta nemmeno mantenendo i numeri piccoli %, ma invece crea una serie di numeri enormi, concatena la loro rappresentazione di stringhe s, ma poi ne estrae solo una parte %. Quindi ho giocato un po 'con il seguente framework:

__*,_f#_f/s_%

(Non puoi farlo per _f/primo, perché ciò produrrebbe zero per almeno i primi 12 elementi.)

Dove _sono alcune permutazioni delle variabili. Non ho provato tutti prima di annoiarmi, e il problema principale era che la sequenza di cifre risultante era sempre troppo lunga.

A un certo punto mi è venuto in mente che non avremmo bisogno di un intervallo così ampio (cioè il prodotto di due numeri), se invece avessimo usato il *per ripetere la stringa risultante. A causa della mancata corrispondenza dei parametri di *e %questo non produrrebbe alcuna ripetizione nel risultato:

_,_f#_f/s_*_%

Ciò ha prodotto risultati molto simili a quello che cercavo. Avrei effettivamente provato tutti e 240, ma abbastanza rapidamente (terzo o quarto tentativo), mi sono imbattuto in

E,Cf#If/sG*K%

che cede

03081942753650251594592190492275006661328850322159030034930530649722385533653290754678977

E ho pensato che una partita delle prime sei cifre non sarebbe stata una coincidenza. Quindi la domanda era come riordinarla senza stravolgere il calcolo effettivo:

  • Non potevo cambiare Kperché questo avrebbe raccolto cifre completamente diverse.
  • Non potevo cambiare Co Iperché ciò avrebbe cambiato i numeri risultanti dalle due operazioni della mappa.
  • Se lo cambiassi, Gcambierebbe solo il numero di ripetizioni, il che non farebbe altro che cambiare la lunghezza del risultato. (Che è buono.)
  • Se lo cambiassi, Eciò cambierebbe l'intervallo dell'array, ma l'intervallo inizierebbe comunque [0 1 2 3 ...], quindi non influirebbe sul calcolo. Si potrebbe influenzare la lunghezza della stringa di base restituita da s, il che significa anche che K%sarebbe scegliere cifre differenti su ripetizioni supplementari.

Scambiando Così ho appena provato Ee Ge voilà:

030819828850379075460427536222159187897761502517030034671154875945928930530907551421904962649729

In sintesi, ecco cosa fa il codice:

G,            "Push [0 1 2 3 ... 13 14 15].";
  Cf#         "Raise each element to the 12th power.";
     If/      "Divide each element by 18.";
        s     "Concatenate all numbers into a string.";
         E*   "Repeat 14 times.";
           K% "Pick every 20th digit.";
— Martin Ender
fonte
6

Pyth, taglia 11, di isaacg

:\\w$ ",d,N

Questo è un cattivo abuso di bug proprio lì. Questo viene compilato per:

Pprint("\n",at_slice("\",input(), ",d,N))

Il bug rilevante è che viene \\compilato "\"invece di "\\", che consente di compilare Pyth in una stringa.

— Martin Ender
fonte
Dovrebbe Pprintessere print, o almeno pprint?
— FireFly
@FireFly Ecco cosa ha dichiarato l'output di debug. Forse l'interprete Pyth definisce la propria Pprint?
— Martin Ender,
Oh, okay, non importa allora.
— FireFly
6

Python, taglia 69, di Sp3000

print(sum(list(map(ord,str((dict(((str(dict()),list()),)),str()))))))

È stato difficile ...

— GRC
fonte
1
Bello! Per riferimento, l'originale era print(sum(map(ord,str((dict(list(((str(),str(dict())),))),list()))))), ma ovviamente funzionavano molte diverse permutazioni di parole chiave.
— Sp3000,
2
Questo è un livello di LISP di genitori lì!
— xnor
6

Python 3, 37 byte, di Sp3000

print(sum(b"a".zfill(len(str(...)))))

In modo imbarazzante di gran lunga la parte più difficile è stata capire come convertire la stringa in byte. Ci ho dovuto dormire sopra, e nella notte ho capito "duh, è un byte letterale!"

— Blake Walsh
fonte
Ahaha ben fatto, ho pensato che l'ellissi potesse far inciampare le persone, ma credo di no
— Sp3000
Ho visto i puntini di sospensione e zfill, ma non sapevo degli oggetti byte. Questi potrebbero essere utili in mazze da golf di numeri interi!
— febbraio
Ottimo lavoro! Ho visto solo la stampa e il .zfill e sapevo che la somma poteva farne parte, ma non sono riuscito a risolverlo. Prendi un +1.
— Hosch250,
6

PHP, 53, di PleaseStand

Finalmente rotto:

for($d=57,$o=35;$o+$d<999;)$o+=printf("$d%o",$d+=$o);

La soluzione è arrivata abbastanza rapidamente quando ho notato che la sequenza consiste in numeri decimali e ottali alternati:

Dec: 57...92...132...177...228...285...348...417...492....573....661....756....858....
     571349220413226117734422843528553434864141775449210755731225661136475615328581707
Oct: ..134..204...261...344...435...534...641...754...1075...1225...1364...1532...1707
==Dec:  92  132   177   228   285   348   417   492    573    661    756    858    967

Inoltre, gli intervalli tra ogni serie di numeri sono cresciuti ad una velocità pari al valore restituito da printf()(cioè il numero di caratteri scritti).

— ossifrage schizzinoso
fonte
3
Wow, bel lavoro da detective!
— Sp3000,
6

Python 2, dimensione 132, di Vi.

exec('from string import printable as e\nprint "cqance"\x2Ereplace("q",e[len("fgiillmmooprrsstt")])or ",,,\016:::S[]____tuuvyy" ""')

Grazie per tutte le barre rovesciate e le virgolette :)

Modifica: la versione aggiornata di 96 caratteri:

exec "try:exec'from __future__ import braces\\nt(12)'\nexcept SyntaxError as q:print(q[0][6:])"

Questo è interamente tratto dalla soluzione di Alex in https://codegolf.stackexchange.com/a/41451/32353

— kennytm
fonte
Heh, carino. Mi chiedevo quale fosse la soluzione indotta ...
— FireFly,
Questa non è una soluzione prevista. La soluzione originale non ha elementi "buttati via" come fgiillmmooprrsstto ,,,\016:::S[]____tuuvyy.
— Vi.
exec? Il mio codice sarebbe stato più breve ... Lo stavo emulando con compile+ evalperché mi ero dimenticato di exec...
— Vi.
Implementata la versione più breve. Prova a capire il trucco originale.
— Vi.
5

CJam, taglia 15, di Ypnypn

98,{7%}%{6+}%:+

Dai personaggi indicati, ho immaginato che dovesse essere una delle tre seguenti forme:

__,{_%}%{_+}%:+
_,{_%}%{__+}%:+
__,{_+}%{_%}%:+

che crea un intervallo di due cifre, quindi mappa un'operazione di addizione e modulo (in entrambi gli ordini) sull'intervallo, prima di sommarlo. Quindi ho appena iniziato con il primo e ho sistematicamente provato le permutazioni degli 6789spazi vuoti.

— Martin Ender
fonte
Accidenti, l'ho appena risolto anche io: /
— Ottimizzatore
5

Python 2, misura 61, di FryAmTheEggman

print(dir('~s]l.c:st_''-p_tp.l]-~.:o:Te[_u[.i_')[10][2:][:3])

Sarei molto sorpreso se questo corrispondesse all'originale.

— GRC
fonte
Non lo fa, ma complimenti comunque! Il mio codice era:print''.__doc__[::2][::3].split()[1].split('.')[0][:-~-~True]
— FryAmTheEggman il
Col senno di poi, non avrei dovuto includere le virgolette ...;)
— FryAmTheEggman
@FryAmTheEggman Oh wow - bel programma! Ero convinto che avessi almeno usato dir()per trovare il "get". E sì, sarebbe stato molto difficile senza le virgolette.
— GRC
5

Python 3, Sp3000, taglia 44

print(~(~(()<((),))<<(()<((),))))<<((()<()))

Python 3 mi ha aiutato qui perché sono stato in grado di causare un errore (spostamento a sinistra Nonedi qualcosa) dopo aver stampato la risposta.

— feersum
fonte
Hmm ... sembra che fossi abbastanza dispiaciuto con le mie genitori. Aveva print(~(~(()<())<<((()<((),))<<(()<((),)))))originariamente.
— Sp3000,
5

PHP, taglia 52, di kenorb

_:@print_r(chr(@++$i+pow(3<<5,1)));if($i<2*4)goto _;

(Dio, quanto tempo mi è servito per capire cosa fare del _rsuffisso rimanente . Fino a quando non ho notato che non lo era print, ma print_r...)

— bwoebi
fonte
E io non so come hai fatto a capirlo :) originale: _:print_r(chr(3*pow(2,5)+@++$i));if(@$i<4<<1)goto _;.
— Kenorb,
3
@kenorb a) devi stampare qualcosa, quindi echonon è possibile; printè rimasta; b) hai bisogno di un ciclo, ma per un forciclo, non c'erano abbastanza punti e virgola, e bene, ci sono due punti ... quindi probabilmente un'etichetta lì in combinazione con goto; c) quindi ha bisogno di un if per interrompere il goto-loop. Avendo ora X:print($Y);if($Y)goto X;(X e Y sono segnaposto); d) c'è un ++, ma no =, quindi probabilmente ++$Zda 1 a 8; e) per ottenere lettere da un numero intero, abbiamo bisogno chr()(di solito) - era lì; f) ora dovevo solo trovare i numeri 96 e 8 per chr e if. Quindi inserire segnaposto e volià.
— bwoebi,
5

C, es1024, lunghezza 70

e='C',f;main(g){Chorkil:f=printf("40%.d",e+e-  -g);}hAx;*hotpoCkats();

La parte difficile è stata quella di tenere traccia di tutti i personaggi non necessari ... sul serio ... Ho dovuto rifarli circa 10 volte. L'unico che mi preoccupava era il, .ma in qualche modo l'ho bloccato nel mezzo della printfstringa di formato ed è diventato invisibile!

— feersum
fonte
5

Haskell, taglia 34, di Petr Pudlák

main=print(0xb2f3d5^0x7f1f27::Int)

Si noti che questo programma deve essere eseguito su un computer a 32 bit. Se vuoi verificare che questo sia il programma corretto e hai una macchina a 64 bit, puoi invece usarlo:

import Data.Int
main=print(0xb2f3d5^0x7f1f27::Int32)

È stato abbastanza facile indovinare il "frame" del programma main=print(0x<hex digits>^0x<hex digits>::Int). Tutta la magia stava nel cercare il modo giusto di suddividere e ordinare le cifre. Non sono stato molto intelligente qui, solo una ricerca di forza bruta ... anche se mi sono preso cura di abusare del fatto che alcune cifre fossero duplicate, probabilmente c'erano circa un numero uguale di cifre nella base e nell'esponente, e l'ultima cifra della base quasi certamente non era pari. Il codice di ricerca completo è incluso di seguito; utilizza il pacchetto multiset-comb . La ricerca completa richiede circa 10:33 sulla mia macchina (e produce solo una risposta corretta, ovviamente).

{-# LANGUAGE NoMonomorphismRestriction #-}
import Control.Monad
import Data.Int
import Data.List (inits, tails, group)
import Numeric
import Math.Combinatorics.Multiset

main = print (searchFor (-1121766947))

searchFor n = do
    nl <- [6,5,7,4,8,3,9,2,10,1,11]
    (l_, r_)  <- chooseSubbag nl digits
    l <- perms l_
    guard (last l /= '2')
    r <- perms r_
    guard ((fromString l :: Int32) ^ (fromString r :: Integer) == n)
    return (l, r)

chooseSubbag n = chooseSubbag' n . group
chooseSubbag' n xss = go (drop (n-1) (concat xss)) n xss where
    go _  n xss | n < 0 = []
    go _  0 xss = [([],concat xss)]
    go [] n xss = []
    go m  n (xs:xss) = do
        (kx, tx) <- zip (tails xs) (inits xs)
        (k , t ) <- go (drop (length tx) m) (n-length kx) xss
        return (kx++k, tx++t)

digits = "1223577bdfff"
fromString = fst . head . readHex
perms = permutations . fromList
— Daniel Wagner
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.