Déchiffrer le code source [thread de braquage pour les tentatives de crack]

44

C'est le fil qui accompagne le défi principal Déchiffrer le code source . Si vous pensez avoir réussi à déchiffrer une des réponses du flic, vous devriez poster votre solution comme réponse à ce fil.

Pour rappel, vous avez une tentative de casser chaque soumission. Votre tentative de cracking sera une version non cryptée du code source. Si votre proposition correspond à la description (mêmes caractères, même résultat, et bien sûr, votre langue) et que vous êtes la première proposition correcte, vous gagnez un point. Il est important de noter que votre programme ne doit pas nécessairement correspondre exactement à l'original, utilisez simplement les mêmes caractères et disposez des mêmes fonctionnalités. Cela signifie qu'il pourrait y avoir plus d'une bonne réponse.

Le voleur avec le plus de points (réussies) gagne.

Classement

Trop de solutions

20 résout

15 résout

10 résout

7 résout

5 résout

4 résout

3 résout

2 résout

1 résoudre

cops-and-robbers 
— PhiNotPi
source
1
Perl 5, taille 27, de Morot - print'pin '= ~ tr (a-za) (za-z) r
@ WumpusQ.Wumbley Nous avons tous été là ...;)
— Martin Ender
3
Je refuse de perdre mon temps à essayer de l'apaiser.
Compte tenu des deux corps de questions, il semble que les réponses brouillées / non brouillées soient inversées
— Mooing Duck
Ruby, 23 par MegaTom = p% ++. Méthodes [80] [1 ..- 1]
— histocrate

Réponses:

32

CJam, taille 20, de Martin Büttner

Hi "petStorm!", mame

Essayez-le en ligne.

Comment ça marche

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

Casser le code

La sortie souhaitée 2.956177636986737, est soit un double, soit un double suivi d'un long.

En utilisant uniquement les caractères "Stop, Hammer time!", quatre opérateurs intégrés renvoient des doublons non entiers:

  • mS, lequel est asin
  • ma, lequel est atan2
  • me, lequel est exp
  • mt, lequel est tan

Tous contiennent un m, nous pouvons donc en utiliser au plus trois. Il n'y en a qu'un Set un a.

Tous ces opérateurs ont besoin d'input et masont le seul à consommer deux intrants. Nous n'avons que trois façons de pousser Longs:

  • "...",, ce qui pousse la longueur de la corde (strictement inférieure à 18).
  • H, ce qui pousse 17.
  • ...!, ce qui pousse le NON logique de ....

Nous n'avons aucun moyen de pousser quelque chose de faux comme ..., donc la dernière option poussera toujours 0.

La sortie ne commence ni ne finit avec 17ou 0. Comme le nombre habituel de chiffres pour un double est de 15 chiffres décimaux, il est probable que la sortie est un simple double.

Dans ce cas, le code doit appartenir à l'une des catégories suivantes:

  • <Long> <mS|me|mt>{1,3}
  • <Long> <mS|me|mt>{x} <Long> <mS|me|mt>{y} ma <mS|me|mt>{z}.
  • N'importe lequel des choix ci-dessus, certains étant convertis en Long ( i) ou en arrondi ( mo) appliqué à un double.

Dans le second cas, x + y + zvaut 1 ou 2 et l’un des longs est 0 ou 17.

Le reste était essentiellement de la force brute. Après quelques essais,

18 , {H \ ma me 2.956177636986737 =} =

retourné 9, ce qui signifie que

H 9 ma me

produit la sortie désirée.

Tout ce qui reste à faire est d'éliminer tous les caractères sauf 9 de la chaîne. Les espaces sont noops et isont un noop sur Longs, "petStorm!"un choix est donc possible.

— Dennis
source
1
C'est fou - comment avez-vous calculé le nombre?
— Sp3000
1
J'ai cherché le logarithme (et d'autres) de ce nombre mais je n'ai obtenu aucun résultat. Maintenant, j'ai trouvé que j'utilisais trop de précision.
— Jimmy23013
2
@ Sp3000: j'ai modifié ma réponse.
— Dennis
1
Très agréable! J'aurais dû retirer deux autres caractères de la chaîne, je suppose. Dans mon original, les espaces restaient toujours dans la chaîne, mais mravant de prendre la longueur. Non pas que vous ne l'auriez pas compris aussi bien à un moment donné. ;)
— Martin Ender
25

Python 3, taille 12, par xnor

()and bciprt

Ne fait rien (l'expression produit un tuple vide, qui n'est pas imprimé). Cela fonctionne en raison d'une évaluation de court-circuit.

— Matsjoyce
source
1
En Python 3 IDLE, ceci est généré ().
— Hosch250
@ hosch250 Depuis qu'il est dans un programme (un fichier python), rien n'est sorti, car il n'y en a pas print.
— Matsjoyce
Je vois. Je courais de la chose en ligne de commande.
— Hosch250
47
.... "chose" ....
— TheDoctor
4
@Imray En raison d'un court-circuit - Python charge le tuple et vérifie si la valeur du tuple est vraie. Comme il est vide, il est faux. Le code pour charger la variable bciprtn'est jamais exécuté, il ne génère donc jamais de NameError.
— Mateon1
20

Python, taille 74, par xnor

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

C'était amusant. Merci à FryAmTheEggman, hosch250 et isaacg pour leurs suggestions et leur aide.

— Sp3000
source
1
Bon travail! Ma solution était assez similaire: list(\nprint(range is range)for aacdeeeeehmppprrrrssvwy in\noct(int is int)).
— xnor
@xnor LOL ce nom de variable. Est-ce dommage que je n'aurais jamais pensé à cela? : P
— FryAmTheEggman
2
@FryAmTheEggman Je pense que tout le monde s'attendait à ce que j'utilise le truc de mon premier flic .
— xnor
@FryAmTheEggman Ne vous inquiétez pas, vous n'êtes pas le seul: P
— Sp3000
13

Python 2, taille 50, par Geobits

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

Sorties 42.

— Ypnypn
source
1
Avoir un point :) Pour référence, original était print 2**2**2**2/2**2**2/2**2**2/2-2**2**2*2**2-22, mais il n'est pas surprenant du tout que plus d'une option est correcte.
— Geobits
13

GolfScript, taille 13, de Peter Taylor

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

Testez-le ici.

Un autre, que je n'ai craqué qu'avec une grande aide de Sp3000. Merci!

Alors voici comment nous en sommes arrivés là. Sp3000 a remarqué plusieurs séries de nombres consécutifs dans la sortie:

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

Sur la base de cette hypothèse, nous avons supposé qu'il s'agissait d'une séquence croissante, qui ne permettait qu'un seul fractionnement possible des nombres restants:

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

C’est 23 chiffres, ce qui est un indicateur fort de la répétition du bloc 22 fois, ainsi que de terminer le bloc avec .(élément dupliqué de la pile supérieure), de sorte que le résultat précédent soit laissé sur la pile et que la dernière itération apparaisse sur la pile deux fois. Ça c'est 22,{____.}/.

Maintenant, en regardant les trous, ils s’avèrent être des 4ème pouvoirs (ce qui est bien, parce que nous avons 4et ?) Plus précisément, ils sont la quatrième puissance de l'indice du nombre actuel. Nous avons ensuite examiné quels indices créaient un écart:

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

En binaire ce sont

00100
00101
00110
00111
01100
01101
01110
01111
10100
10101

Ils ont tous le troisième bit défini, ce qui signifie que l'index est probablement juste au niveau des bits 4(ce qui est bien, parce que nous pouvons en créer un autre 4avec .a &). Cela fonctionne particulièrement bien, car cette opération aboutit à soit, 0soit à 4, et si nous utilisons cela comme exposant, nous obtenons un 1ou quatre pouvoirs, ce qui est exactement ce dont nous avons besoin. Alors mettons cela ensemble:

22,{.4&?+.}/

Voici ce que fait le bloc:

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

Maintenant, il restait deux problèmes: nous avions un vagabond que ,nous n'avions pas encore utilisé, et la première itération est un cas spécial, en ce sens qu'il n'y a pas de valeur d'une itération précédente à laquelle nous pourrions ajouter des choses quand nous les rencontrons +. Nous avons constaté que, grâce à un commentaire sans lien de la part de user23013, qui avait fait remarquer que GolfScript commençait avec une chaîne vide sur la pile (s'il n'y avait rien sur STDIN). Nous pourrions donc utiliser cet autre ,droit au début pour transformer cette chaîne en un 0, ce qui était exactement ce dont nous avions besoin au début de l'itération.

— Martin Ender
source
Spot sur. Cela a été inspiré par une séquence dans OEIS que je ne trouve pas maintenant.
— Peter Taylor
3
Et c’est pourquoi il est judicieux d’avoir un fil séparé pour les voleurs. Bon travail!
— Dennis
11

Rubis, taille 17, par la poignée de porte

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

C'était très amusant. Merci à Sp3000 de m'aider avec ça! Et j'ai appris que les %r?...?littéraux peuvent avoir des délimiteurs. :)

— Martin Ender
source
10
Des accessoires à Doorknob pour avoir été indûment trompeurs avec print, seulement pour le scinder en deux ppour l'impression, les %rexpressions rationnelles et la icorrespondance des expressions rationnelles sans distinction de casse.
— Sp3000
11

PHP, taille 49, par bwoebi

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

C'était absolument mental .

Il faut

print@substr(new exception,);

assez rapidement, à quel point j'avais besoin de quelque chose qui donne -6après la virgule, étant $++$++$++$+=$~main$2parti.

Le principal problème est que $a, $met $isont tous NULL, donc les utiliser indirectement dans des variables variables signifie qu'ils pointent tous vers la même variable. Cependant, PHP semble faire des choses étranges sur la résolution des variables variables. Avec des variables normales, vous pouvez faire des choses comme

echo $a+$a=2;

qui imprime 4(le 2est assigné $apuis ajouté à lui-même). Mais si je fais la même chose avec les variables variables:

echo $$a+$$a=2;

Je reçois 2, parce que maintenant le premier $$aest évaluer avant la cession.

En fin de compte, j'ai réussi à imposer un ordre en mettant quelques incréments sur le RHS +=qui devaient être évalués avant cette addition-affectation. De cette façon, je 5pouvais simplement compléter mon travail. Pourtant… il se passe des choses mystérieuses et je ne sais pas pourquoi la moitié des choses que j'ai essayées ont fonctionné et n'ont pas fonctionné.

— Martin Ender
source
Pour référence, mon original:print@substr(new exception,~$$mn+=2+$$a+++$$i++);
— bwoebi
Btw. J'espère que tous les signes dollar et le fait que toutes les lettres mainétaient dans la chaîne vous induisent en erreur. En outre, une méthode plutôt inhabituelle pour extraire {main}, je pense ;-)
— bwoebi
@bwoebi The mainne m'a pas vraiment induit en erreur, après avoir repéré exception, newet substr. Je pensais qu'ils ne seraient que des noms variables. Il m’a fallu un peu pour arriver à utiliser des variables variables et que j’ai passé la plupart du temps à déterminer un ordre d’opérations qui produirait un résultat 5que je pourrais compléter sans utiliser un autre jeu de parenthèses.
— Martin Ender
Eh bien, pour la prochaine fois, s'il y a plus d'argent que de caractères, ce sont généralement des variables variables. (Dans ce cas, j'ai également abusé de varvars pour forcer une évaluation de gauche à droite.) Combien de temps vous a-t-il fallu pour repérer la nouvelle exception substr? De plus, en passant, j'ai une connaissance plus approfondie du moteur Zend, je peux donc parfaitement m'expliquer pourquoi les choses sont évaluées dans quel ordre et que c'est bien pour ces défis ;-) S'il y a quelque chose de particulier que vous n'obtenez pas, je ' Je t'expliquerai avec plaisir.
— Bwoebi
@bwoebi Venez discuter demain, nous pourrons en parler, mais j'ai passé assez de temps à ce sujet aujourd'hui. ;) Quant à votre première question, exceptionétait évident, ce qui laissait des caractères errants substret newtraînants. C'était littéralement la première chose que j'ai vue en commençant à travailler dessus.
— Martin Ender
9

Rubis, taille 38, par la poignée de porte

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

Je suis à peu près sûr que cela est loin de la source originale. C'est déterministe malgré l'utilisation rand.

Voici comment celui-ci fonctionne. $><<est juste sortie. $pece60et $winsont des variables globales non définies, qui sont donc justes nil(et elles m'ont permis de supprimer certains caractères superflus). !$pece60fait un trueet to_sdonne la chaîne "true".

Pendant des années, j’ai essayé d’obtenir un 2ou -2d’y accéder u, mais j’ai alors réalisé que je pouvais prendre le t, et appeler .succ(essor) dessus pour en faire un u.

randavec un nilparamètre renvoie un nombre aléatoire dans l'intervalle [0,1). Lorsque vous utilisez des éléments flottants pour indexer des chaînes, elles sont tronquées en entiers, ainsi le premier caractère est toujours renvoyé.

Enfin, j'avais une paire de rechange, []alors je viens de tout emballer, car heureusement, tout est une expression en Ruby.

Merci à Sp3000 pour avoir lancé quelques idées dans le chat.

— Martin Ender
source
8
Ruby est une langue effrayante.
— Feersum
8

C, 51 par es1024

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

Après 20 ans de programmation en C, j'ai découvert les constantes hexadécimales à virgule flottante.

— Art
source
8

Ruby, 45 ans (histocrate)

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

Woohoo! C’est ma première tentative face à un problème de golf, et je n’ai pas assez de représentants pour commenter le message original. J'ai tout de suite reconnu le truc utilisé, car j'ai souvent trouvé son utilité dans le code de production. Il a fallu environ 5 minutes pour comprendre la majeure partie de la structure et quelques heures pour trouver la réponse complète.

Explication:

  • %q[]est une méthode alternative pour créer des chaînes. Les parenthèses et les accolades peuvent également être utilisés.
  • String#to_i in Ruby accepte les nombres de toutes les bases de 2 à 36. Il ignorera le premier caractère de la chaîne qui ne fait pas partie du nombre, de sorte que tous les caractères supplémentaires peuvent être "jetés" après l'espace.

Et voici le code que j'ai utilisé pour le déchiffrer:

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

Chemin à parcourir pour intégrer un problème de NP dans une énigme. J'ai été complètement victime de nerd. Bon travail!

— CharredUtensil
source
J'ai ajouté un commentaire à la réponse originale pour vous.
— FireFly
C'est génial (et proche de la réponse attendue), mais techniquement non valide car il n'a pas de sortie.
— Histocrate
* facepalm Eh bien, je m'amusais toujours.
— charredUtensil
2
@charredUtensil Si cela ne vous dérange pas d'exécuter votre script, je pense que l'impression ne fait que déplacer le pà avant l'expression. On peut supposer que les caractères restants peuvent être utilisés pour former les constantes comme vous l'avez fait.
— FireFly
Je n'ai pas réellement besoin de l'exécuter à nouveau. Les derniers caractères de la chaîne peuvent être réarrangés sans changer le résultat - p %q[zyfnhvjkwudebgmaclrsx].to_i(36)/51074892je sais que j'ai brisé ma tentative de cracking réelle :)
— charredUtensil
7

Coquille en python [toute] taille 44, de Caridorc

__name__[3]  or (enfin_____[42], manager[1])

Je suis sûr qu'il était supposé être plus compliqué que cela, mais comme cela __name__équivaut à __main__, le 4ème caractère "a" est sélectionné et le reste de la ligne n'est jamais évalué.

— ossifrage délirant
source
Juste pour référence le programme original est[__name__ for ___name__ in range(1,4)][2][3]
— Caridorc
7

CJam, taille 13, par utilisateur23013

G,Cf#If/sE*K%

Testez-le ici.

Résolu à la main, comme ceci:

Tout d’abord, quelques informations pour les non-CJammers:

  • CEGIKsont toutes les variables, qui sont pré-initialisé à 12, 14, 16, 18, 20, respectivement.
  • s convertit l'élément de pile supérieur en chaîne.
  • Les chaînes ne sont techniquement que des tableaux de caractères.
  • fest assez magique. Aux fins de cette réponse, la version simplifiée est que, pour un tableau a, une autre valeur bet un opérateur g, la séquence des abfgcartes g(_,b)sur a(où chaque élément de apasse dans la _fente).
  • / est la division et la division des tableaux (entre autres).
  • * est la multiplication et la répétition de tableau (entre autres).
  • %est modulo et une opération étrange qui, sous la forme ad%de tableau aet d’entier, dprend chaque délément th de a(comme le découpage avec largeur de pas de Python d).
  • # est l'exponentiation (entre autres).
  • ,transforme les nombres en plages (de 0à n-1) et renvoie la longueur d'un tableau.

Ok, ça se passe loin ...

Il était assez évident que nous devions ,transformer un nombre en une plage, car la seule autre façon d’obtenir un tableau aurait été de construire un nombre plus grand et de le transformer en tableau de caractères avec s- mais alors nous n’aurions pas pu le faire. plus d'arithmétique sur elle. Et nous avons besoin d'un tableau pour faire quelque chose avec le fs.

J'ai d'abord supposé que les fs étaient utilisés avec #et %, mais cela voudrait dire que nous aurions eu besoin d'un nombre d'environ 90 pour obtenir le nombre correct de chiffres à la fin. Et aussi, cela n’expliquait pas quoi faire s, et comme la réponse semblait vraiment gaie, je doutais que user23013 soit simplement ajouté scomme un no-op efficace, quelque part pour jeter les gens.

Donc, je me suis dit qu'il ne gardait peut-être même pas un petit nombre %, mais au lieu de cela, il construit un tableau d'énormes nombres, concatène leur représentation sous forme de chaîne avec s, mais ne retient que quelques tranches bizarres %. J'ai donc joué un peu avec le framework suivant:

__*,_f#_f/s_%

(Vous ne pouvez pas le faire en _f/premier, car cela donnerait zéro pour au moins les 12 premiers éléments.)

Où _sont les permutations des variables. Je ne les ai pas toutes essayées avant de m'ennuyer, et le principal problème était que la séquence de chiffres résultante était toujours trop longue.

À un moment donné, je me suis dit que nous n'aurions pas besoin d'une plage aussi large (le produit de deux nombres) si nous utilisions plutôt le *pour répéter la chaîne résultante. En raison de la discordance des paramètres de *et %cela ne donnerait aucune répétition dans le résultat:

_,_f#_f/s_*_%

Cela a donné des résultats d'une longueur très proche de ce que je cherchais. J'aurais effectivement essayé tous les 240 d'entre eux, mais assez rapidement (troisième ou quatrième tentative), je suis tombé sur

E,Cf#If/sG*K%

qui donne

03081942753650251594592190492275006661328850322159030034930530649722385533653290754678977

Et je me suis dit qu'une correspondance des six premiers chiffres ne serait pas une coïncidence. La question était donc de savoir comment le réorganiser sans perturber le calcul réel:

  • Je ne pouvais pas changer Kparce que cela choisirait des chiffres complètement différents.
  • Je ne pouvais pas changer Cou Iparce que cela changerait les nombres résultant des deux opérations de carte.
  • Si je changeais, Gcela ne changerait que le nombre de répétitions, ce qui ne ferait que changer la longueur du résultat. (Ce qui est bon.)
  • Si je changeais Ecela changerait la plage du tableau, mais la plage commencerait toujours par [0 1 2 3 ...], donc cela n'affecterait pas le calcul. Il aurait une incidence sur la longueur de la chaîne de base retournée par s, qui signifie également que K%choisirait des chiffres différents sur des répétitions supplémentaires.

Alors j'ai juste essayé d'échanger Eet Get le tour est joué:

030819828850379075460427536222159187897761502517030034671154875945928930530907551421904962649729

En résumé, voici ce que fait le code:

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
source
6

Pyth, taille 11, par isaacg

:\\w$ ",d,N

C'est là un abus de bogue méchant. Cela compile pour:

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

Le bogue pertinent est que \\compile to "\"au lieu de "\\", ce qui vous permet de compiler Pyth en une chaîne.

— Martin Ender
source
Le devrait-il Pprintêtre print, ou du moins pprint?
— FireFly
@FireFly C'est ce que la sortie de débogage a déclaré. Peut-être que l'interpréteur Pyth définit sa propre Pprint?
— Martin Ender
Oh, d'accord, c'est pas grave alors.
— FireFly
6

Python, taille 69, par Sp3000

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

C'était dur ...

— grc
source
1
Agréable! Pour référence, l'original était print(sum(map(ord,str((dict(list(((str(),str(dict())),))),list()))))), mais évidemment, beaucoup de permutations différentes de mots-clés fonctionneraient.
— Sp3000
2
C'est un niveau de parens LISP!
— xnor
6

Python 3, 37 octets, par Sp3000

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

De manière embarrassante, le plus difficile était de loin de trouver comment convertir la chaîne en octets. J'ai dû dormir dessus et dans la nuit, j'ai réalisé: "C'est un octet littéral!"

— Blake Walsh
source
Ahaha bien fait, je pensais que les Ellipsis pourraient faire trébucher les gens, mais je suppose que non
— Sp3000
J'ai vu les points de suspension et zfill, mais je ne connaissais pas les objets octets. Ceux-ci pourraient être utiles dans les tableaux de golf de nombres entiers!
— Feersum
Bon travail! J'ai seulement vu l'empreinte et le .zfill, et je savais que sum pourrait en faire partie, mais je ne pouvais pas le résoudre. Avoir un +1.
— Hosch250
6

PHP, 53, par PleaseStand

Il a finalement craqué:

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

La solution est venue assez rapidement lorsque j'ai remarqué que la séquence consistait en une alternance de nombres décimaux et octaux:

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

En outre, les intervalles entre chaque ensemble de nombres ont augmenté à un taux égal à la valeur renvoyée par printf()(c.-à-d. Le nombre de caractères écrits).

— ossifrage délirant
source
3
Wow, beau travail de détective!
— Sp3000
6

Python 2, taille 132, par Vi.

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

Merci pour les barres obliques inverses et les guillemets :)

Edit: La version 96 caractères mise à jour:

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

Ceci est entièrement repris de la solution d'Alex dans https://codegolf.stackexchange.com/a/41451/32353

— kennytm
source
Heh, gentil. Vous vous demandez quelle était la solution proposée ...
— FireFly
Ce n'est pas une solution prévue. La solution d'origine ne contient aucun élément "jetable" comme fgiillmmooprrssttou ,,,\016:::S[]____tuuvyy.
— Vi.
exec? Mon code aurait dû être plus court ... Je l'imitais avec compile+ evalparce que j'avais oublié exec...
— Vi.
Implémenté la version plus courte. Essayez de comprendre le truc original.
— Vi.
5

CJam, taille 15, par Ypnypn

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

D'après les caractères donnés, j'ai supposé qu'il devait s'agir de l'une des trois formes suivantes:

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

qui crée une plage de deux chiffres, puis mappe une addition et une opération modulo (dans l’un ou l’autre) sur la plage, avant de la sommer. Je viens donc de commencer avec le premier et j'ai systématiquement essayé les permutations des 6789trous.

— Martin Ender
source
Bon sang, je viens de le résoudre aussi: /
— Optimizer
5

Python 2, taille 61, par FryAmTheEggman

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

Je serais très surpris si cela correspond à l'original.

— grc
source
Ce n'est pas le cas, mais félicitations quand même! Mon code était:print''.__doc__[::2][::3].split()[1].split('.')[0][:-~-~True]
— FryAmTheEggman
Avec le recul, je n'aurais pas dû inclure les citations ...;)
— FryAmTheEggman
@FryAmTheEggman Oh wow - bon programme! J'étais convaincu que vous aviez au moins l'habitude dir()de trouver le "get". Et oui, cela aurait été très difficile sans les citations.
— grc
5

Python 3, Sp3000, taille 44

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

Python 3 m'a aidé ici car j'ai pu provoquer une erreur (décalage Nonevers la gauche de quelque chose) après avoir imprimé la réponse.

— feersum
source
Hmm ... on dirait que j'ai gaspillé mon temps avec mes parens. Avait à l' print(~(~(()<())<<((()<((),))<<(()<((),)))))origine.
— Sp3000
5

PHP, taille 52, par kenorb

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

(Mon dieu, combien de temps il m'a fallu pour comprendre quoi faire avec le _rsuffixe restant . Jusqu'à ce que j'ai remarqué que ce n'était pas le cas print, mais print_r...)

— bwoebi
source
Et je ne sais pas comment avez - vous le comprendre :) Original: _:print_r(chr(3*pow(2,5)+@++$i));if(@$i<4<<1)goto _;.
— Kenorb
3
@kenorb a) vous devez imprimer quelque chose, donc echoimpossible; printest resté; b) vous avez besoin d'une boucle, mais pour une forboucle, il n'y avait pas assez de points-virgules, et bien, il y a un colon ... donc probablement une étiquette associée à goto; c) alors il faut un if pour abandonner la boucle goto. Ayant maintenant X:print($Y);if($Y)goto X;(X et Y étant des espaces réservés); d) il y a un ++, mais non =, donc probablement ++$Zde 1 à 8; e) pour obtenir des lettres d'un entier, nous avons besoin chr()(généralement) - c'était là; f) maintenant je devais juste trouver les nombres 96 et 8 pour chr et if. Puis remplissez les espaces réservés et volià.
— Bwoebi
5

C, es1024, longueur 70

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

La partie difficile a finalement été de garder une trace de tous les personnages inutiles ... sérieusement ... je devais les refaire environ 10 fois. Le seul qui m'inquiète était le .mais je l'ai quand même collé au milieu de la printfchaîne de format et il est devenu invisible!

— feersum
source
5

Haskell, taille 34, de Petr Pudlák

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

Notez que ce programme doit être exécuté sur une machine 32 bits. Si vous voulez vérifier que c'est le bon programme et que vous avez une machine 64 bits, vous pouvez utiliser ceci à la place:

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

Il était assez facile de deviner le "cadre" du programme main=print(0x<hex digits>^0x<hex digits>::Int). Toute la magie consistait à chercher le bon moyen de partitionner et de commander les chiffres. Je ne faisais pas très intelligent ici, juste une recherche de force brute ... même si j'ai pris soin d'abuser du fait que certains chiffres étaient dupliqués, il y avait probablement à peu près le même nombre de chiffres dans la base et l'exposant, et le dernier chiffre de la base n'était certainement même pas. Le code de recherche complet est inclus ci-dessous; il utilise le paquet multiset-comb . La recherche complète prend environ 10h33 sur ma machine (et ne produit qu'une seule bonne réponse, bien sûr).

{-# 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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.