Ceci est la question complémentaire pour les mots croisés de code . Les réponses des voleurs vont ici.
Voir Où devrions-nous mettre les voleurs? pour les méta-informations.
Ceci est la question complémentaire pour les mots croisés de code . Les réponses des voleurs vont ici.
Voir Où devrions-nous mettre les voleurs? pour les méta-informations.
Réponses:
J'ai dû truquer un peu sur 7-Down en invoquant un comportement indéfini. es1024 a indiqué que cette utilisation de l'UB était la solution envisagée. Cela fonctionnera sur les ordinateurs de la plupart des gens. Je suis venu avec diverses expressions obtenir le résultat souhaité, comme -1 << 30
, 3 << 30
, 6 << 29
et , ~(~0U/4)
mais tous a rendu impossible pour moi d'obtenir 5 travers. J'ai donc utilisé la propriété spécifique à l'architecture Intel que seuls les 5 bits les moins significatifs sont utilisés pour déterminer la taille d'un décalage vers la gauche. Notez qu'il doit l'être ~_
et non ~1
pour que la quantité à décaler ne soit pas une constante de temps de compilation. J'ai testé les expressions avec le code suivant:
#define T(X) _ = c; _ = X; printf("%d\n", _);
z[4] = {9};
int main(c)
{
int _;
T("01"[0])
T(-8)
T(-2)
T(11<-328111)
T(+2+71)
T(9+0)
T(0**z)
T(5;)
T(0<-000)
T(2+~3)
T(!91)
T(!_)
T(2**z)
T('_T;')
T("11"?5*9:2)
T(15<<9)
T(0+22)
T(-211*0-97;)
T(-17*0)
T(3+0<<~_)
T(8+000)
T(+0)
T(42)
T(+!z)
T(~_)
}
#define T
comme un élément nécessaire à votre solution. La question demeure, cependant, pourquoi M-across fonctionne-t-il? La définition d'une constante à plusieurs caractères concatène-t-elle simplement les valeurs d'octet? Si oui, j'ai appris quelque chose de nouveau aujourd'hui. :)
int
, vous pouvez donc mettre jusqu'à quatre octets sans perte d'informations.
(Cette solution nécessite en fait plusieurs espaces, ce n'est donc pas celui que le professeur recherchait.)
#K###I#'32
#HDJ*s\ ##
2##2#`#`#-
4Zm*`##L#3
m##6##]`'
f####e#`#'
`#0#'d1+eu
## #!####9
## '{;'"'m
C5(#}####q
C'était très amusant. Notez que le #
sous le 6
est en fait du code et non une cellule sombre. Passons par là:
Astuce 2: [[4 3]]
. Ce fut l'un des plus délicats, car je suis vraiment resté coincé à essayer 4Z]]`
ou similaire. Il s'avère que vous pouvez utiliser le produit cartésien m*
sur des choses qui ne sont pas un tableau, et il en fera un tableau pour vous. Voici donc:
4Zm*`
Astuce 4: 24717
. Au moment où je suis arrivé à cela, le H
, J
, s
et l' espace de fuite étaient déjà en place. Le H
cadeau que je pourrais probablement réutiliser 17
et faire \
à la fin. Le J
pousse un 19
et 247 == 13 * 19
donc:
HDJ*s\
Astuce 7: 32
. Il y a un tas de façons de le faire: Y5#
, 3 2
, ZY
, YZ\
, 4(2
, 2)2
, '32
. Je suis allé avec le dernier, car commencer avec un personnage semblait prometteur pour 7-down, et cela s'est avéré juste.
Astuce 8: E
. J'avais déjà le 'd
quand je suis arrivé, donc c'était entre choisir 'd1+eu
, 'deu1+
ou une variante où j'utilisais )
et un espace au lieu de 1+
(pour les personnes non-CJam, cela prend le d
caractère et l'incrémente et le majuscule, dans l'un ou l'autre ordre) . Cependant, le u
dans la dernière colonne semblait utile pour A-down. J'ai donc choisi le premier d'entre eux. En fin de compte, 'd) eu
cela aurait aussi fonctionné.
Astuce 9: ""
. Eh bien, cela devait être "chaîne vide, obtenir une représentation de chaîne, pousser un espace". Mais j'avais également besoin du `pour la représentation des chaînes dans 7-down, et un espace dans A-down semblait utile aussi, alors j'ai choisi
]`'
Notez que cela ]
pourrait également être l'un des LMOQR
.
Astuce B: "m
. Je devais vraiment adapter celui-ci au reste, mais il y avait peu de personnages qui comptaient. J'avais déjà le {
et le m
. Donc, au lieu d'utiliser un bloc, je me suis transformé {
en personnage , je l'ai jeté, puis j'ai poussé les deux caractères requis:
'{;'"'m
Astuce D: 124
. J'ai résolu celui-ci avec C-down, ce qui était plus facile avec un décrément à la fin. Je pousse donc un 12, un 5 et décrémente ce dernier:
C5(
Conseil 1: [2 2 2 3]
. Cela ressemblait trop étrangement à une factorisation primordiale pour qu'elle n'en soit pas une. :)
24mf`
Astuce 3: 3010936384
. L'affacturage a montré qu'il s'agit en fait de 38 6 . La seule question était de savoir comment obtenir la 38
conformité avec 2-travers. Au final, j'avais besoin d'un *
troisième à la troisième place, donc le doubler 19
:
J2*6#
Astuce 5: 2017
. Deux personnages pour un si grand nombre? Utilisez simplement des variables à deux chiffres intégrées:
KH
Astuce 6: "18"
. Je pense qu'il n'y a qu'une seule façon de le faire en 3 caractères. Utilisez le 18 intégré, convertissez-le en chaîne, puis en sa représentation sous forme de chaîne.
Is`
Astuce 7: ' "\"\""
. Probablement la partie la plus difficile du puzzle. En particulier, je devais obtenir le "\"\""
en seulement trois caractères. L'astuce consistait à obtenir deux fois la représentation sous forme de chaîne de la chaîne vide. Cela a conduit à:
' `L``+
Ce +
n'est pas nécessaire, mais était nécessaire par 8 à travers.
Astuce 8: !{}
. Le bloc devait aller dans le code, ce qui ne laissait que deux caractères pour !
, ce qui signifiait utiliser un autre littéral:
'!{}
Astuce A: -3u3
. Avec le u
8 en place, j'ai commencé à mettre -3
et 3
dans les coins où aucun autre indice ne les concernait. Mais alors j'avais besoin d'un m
en bas. Je pense qu'il existe plusieurs façons d'obtenir un 3
avec _m_
, mais le plus simple était de prendre la racine carrée de 9:
-3 'u9mq
Astuce C: -1
. J'avais déjà le décrément là-bas, alors j'ai juste mis un 0
endroit où personne d'autre ne se souciait:
0 (
Astuce E: Stack: ""
. Eh bien, c'était le plus simple. Appelez simplement le débogueur:
ed
COTO, Javascript ES4, 37 Darks
__________
|{}=51###6#|
|a##.#I-9<4|
|:##-##"#<#|
|5+Math.PI#|
|}##+##.#+#|
|["9"+0][0]|
|'##p##"###|
|a+-a#a=-10|
|'##c##=###|
|]##"\x48I"|
¯¯¯¯¯¯¯¯¯¯
5+Math.PI
ou Math.PI+5
; mais ce dernier laisserait «M» et «h» se croiser dans d'autres expressions, semblait peu probable."\x48I"
.xxxa
évalué à zéro, donc -a + a? un + -a? 3 + -a? a+-a
avait l'air mieux car il m'a donné ce qui ressemblait à un char dans une chaîne en 1dn.{x:5}xxa'x
. Étant donné que la valeur renvoyée est 5, elle doit être extraite de l'objet, ce {x:5}['a']
qui signifie que le dernier caractère manquant est également un:{a:5}['a']
t={}=51
et cela a fonctionné. Ne savais pas ça!5xxax"pac"
=> "2pac". Cela doit être 5-a+"pac"
, en quelque sorte, donc le deuxième caractère doit être '.' pour le littéral à virgule flottante.[xx"xxxx]
, retournant "90". Donc, cela doit être un littéral de tableau avec la valeur retirée; il n'y a de place que pour une seule valeur, donc nous en avons [xx"xx][0]
. Il n'y a pas de place pour deux cordes, mais soit "9"+0
ou en 9+"0"
forme.6<<I
s'est avéré être la réponse, laissant +0 pour ajouter à la fin.I-I<4
, I-6<4
etc.)-x..]xxx4
. Le ".." m'a jeté - il n'y a que quelques façons qui peuvent être une syntaxe légale et c'est pourquoi j'ai demandé si ES4 était ce qui était prévu - était-ce une caractéristique étrange de cette spécification abandonnée? Mais alors j'ai vu que c'était un hareng rouge; -""
est NaN, donc -"..]"xx4
doit être ce qu'il y a - une comparaison avec NaN, renvoyant false; '==' fera l'affaire, mais il faut regarder la dernière réponse pour confirmation ...=-10
. Pour être honnête, j'ai également regardé la version précédente de 9dn et j'ai réalisé que cela devait être quelque chose =top
(pour récupérer une fenêtre). La variable affectée à pourrait être a ou I, cela n'a pas d'importance.Puzzle délicat!
Pour toutes les longues expressions à virgule flottante, j'ai créé un programme C ++ pour générer des expressions mathématiques Python par la force et les évalue. Il suppose que tous les nombres sont à virgule flottante et ne prend en charge que les opérateurs +, -, *, /, //, ** et ~. Je l'ai utilisé pour obtenir chaque indice de plus de 5 caractères, sauf a**9*27%b
le hachage. Avec 6 blancs ou moins, il se termine en quelques secondes, alors qu'il y a un peu d'attente pour 7.
Je suppose que j'ai assez bien joué à celui-ci, car il y a 14 espaces.
Ce script de test:
g=4;
o=magic(3);
D=@disp;
D(max([ 2]));
D( i^3);
D(o^0);
D(6 -7+eye );
D((i));
D(.1 ^5* g );
D(~2);
D(diag(~o) );
D(asin (1)*i);
D((93+7) +~g);
D( 10e15);
D(2*ones (2));
D(02 ^ 9 );
D(-i );
D(~o);
produit la sortie suivante:
2
0 - 1.0000i
1 0 0
0 1 0
0 0 1
0
0 + 1.0000i
4.0000e-05
0
0
0
0
0 + 1.5708i
100
1.0000e+16
2 2
2 2
512
0 - 1.0000i
0 0 0
0 0 0
0 0 0