Votre patron vient de vous envoyer par courrier électronique une liste de 12 tâches de programmation dont il a besoin d’être effectuée dès que possible. Les tâches sont assez simples, mais votre patron, étant un jeune magnat du logiciel séduit par les réseaux sociaux, insiste sur le fait que vos solutions peuvent s’intégrer dans un seul tweet Twitter .

Cela signifie que vous ne disposez que de 140 octets de code pour résoudre toutes les tâches, soit une moyenne de 11,67 octets par tâche. (Oui, Twitter compte les caractères, mais votre patron a spécifiquement indiqué des octets.)

Vous réalisez qu'il n'y a aucun moyen de résoudre les 12 tâches sur 140 octets, mais vous pensez que votre supérieur ne testera pas toutes vos solutions. Vous devez donc résoudre autant de tâches que vous le pouvez, en en sautant complètement certaines. Votre état d' esprit est qu'il n'a pas d' importance qui sous - ensemble des tâches que vous complet, il importe seulement que le sous - ensemble est aussi grand que possible .

Combien de tâches pouvez-vous accomplir?

Défi

Ecrivez jusqu'à 12 programmes différents, dont chacun résout avec précision l'une des 12 tâches énumérées ci-dessous. La somme cumulée des longueurs de ces programmes ne peut dépasser 140 octets.

Alternativement, vous pouvez écrire un programme unique ne dépassant pas 140 octets prenant un entier compris entre 1 et 12 et (idéalement) procédant à la résolution de la tâche correspondante, en prenant plus d'entrées si nécessaire. Toutes les tâches ne doivent pas nécessairement fonctionner, mais seules celles qui comptent pour votre score. Les tâches qui ne fonctionnent pas sont autorisées à commettre des erreurs ou à faire autre chose.

Dans les deux cas, un "programme" peut en fait être une fonction qui prend l’entrée comme argument ou qui l’invite, puis l’affiche ou la renvoie. Ainsi, par exemple, vous pouvez écrire une fonction de 140 octets qui ressemble à f(taskNumber, taskInput), ou vous pouvez écrire des extraits de code séparés pour chaque tâche, certains en tant que fonctions et d'autres en tant que programmes à part entière.

Autres détails:

• Tout le code doit être écrit dans la même langue.

• Comme d'habitude, l'entrée doit provenir de stdin, de la ligne de commande, d'un argument de fonction ou de ce qui est habituel pour votre langue. La sortie est imprimée sur stdout ou l'alternative la plus proche de votre langue, ou renvoyée dans un type approprié.

• Une quantité raisonnable de formatage d’entrée suffit. Par exemple, des guillemets autour de chaînes ou à la \nplace des sauts de lignes réels.

• La sortie doit correspondre exactement à ce qui est demandé, sans mise en forme superflue ni espace. L'exception est une nouvelle ligne de fin unique.

• Le code qui ne fonctionne que dans un environnement REPL ne constitue pas un programme ou une fonction.

• Vous ne pouvez pas écrire plusieurs programmes qui résolvent plusieurs tâches. C'est soit un programme qui (idéalement) résout toutes les tâches, soit (idéalement) 12 programmes qui résolvent chacun une tâche unique.

• La publication d'une solution de tâche que vous n'avez pas écrite ou que vous n'avez que légèrement modifiée n'est pas autorisée sans attribution à l'auteur d'origine et, idéalement, pour obtenir l'autorisation également. Si votre réponse compose principalement les solutions les plus courtes parmi toutes les autres réponses, il devrait s'agir d'un wiki de communauté.

Notation

La soumission qui accomplit le plus de tâches est le gagnant. Si deux soumissions sont égales, celle qui a le moins d'octets gagne. Si le nombre d'octets est égal, la soumission la plus ancienne l'emporte. Les réponses du wiki de la communauté ne sont pas autorisées à gagner.

Assurez-vous de nous dire quelles tâches vous avez résolues, pas seulement combien!

Handicap pour les non-golfeurs:

Il est probable que ce défi sera dominé par les langues de golf . Beaucoup de langues peuvent avoir du mal à résoudre même une ou deux tâches sur 140 octets. Par conséquent, vous pouvez soumettre une réponse non compétitive lorsque la limite est de 3 tweets, soit 420 octets. Toutes les autres règles restent les mêmes.

les tâches

Tâche 1 - Trois nombres peuvent-ils former un triangle?

Prendre trois nombres entiers positifs et sortir une valeur de vérité / fausseté indiquant si trois lignes avec ces longueurs peuvent former un triangle . Vous ne pouvez pas supposer que les chiffres sont dans un ordre particulier.

Exemples de vérité (un par ligne):

20 82 63
1 1 1
2 3 4
1 2 2

Exemples de fausseté:

6 4 10
171 5 4
1 1 2
1 2 3

---

Tâche 2 - Plus proche du million

Avec une chaîne contenant exactement 7 chiffres décimaux (0 à 9), réorganisez-les pour obtenir un nombre aussi proche que possible du million. C'est, abs(1000000 - rearrangedNumber)devrait être minimisé.

Imprimer ou renvoyer le nombre obtenu sous forme de nombre entier et non de chaîne (il ne devrait donc pas y avoir de zéros au début, à moins que ce ne soit la norme pour votre langue).

Par exemple, une entrée de 9034318doit avoir pour résultat 984331(et non 1033489).

2893984devrait devenir 2348899.

0001000devrait devenir 1000000.

0000020devrait devenir 200000.

---

Tâche 3 - Simulateur de clavier simple

Prenez une chaîne de lettres minuscules (az), des espaces et des crochets <>. Lue de gauche à droite, cette chaîne représente les touches sur lesquelles vous avez appuyé sur un clavier standard alors qu'un éditeur de texte initialement vide était ouvert. Les lettres et les espaces correspondent à leurs touches normales mais <correspondent à la flèche gauche et >à la flèche droite, qui déplacent le curseur lorsqu'elles sont enfoncées.

<déplace le curseur d'un caractère à gauche, ou ne fait rien si le curseur se trouve au début de la chaîne.
>déplace le curseur d'un caractère à droite, ou ne fait rien si le curseur se trouve à la fin de la chaîne.

Affiche la chaîne qui serait dans l'éditeur de texte une fois que toutes les touches de la chaîne ont été enfoncées. La sortie de codes d'échappement pour déplacer le curseur n'est pas autorisée.

Il y aura toujours au moins un caractère de touche non-flèche dans l'entrée.

par exemple, l'entrée ui<<q>>ck <<<<<<the<<<<>>> >>>>>>>>brown x<o<fdevrait donner the quick brown fox.

op<<l>>t<<<lam>>>>>>imi<<<><>>>zer<<<<<<<<<<<<<<<<<<>>><>mdevrait donner llammoptimizer.

e< <c<b<adevrait donner abc e.

<<<>><><<><toast>><<>><><<>><devrait donner toast.

---

Tâche 4 - Lettres FILTHE

Dans de nombreuses polices, 6 des lettres de l' alphabet anglais majuscules se composent uniquement de lignes horizontales et verticales: E, F, H, I, Let T. Nous les appellerons les lettres FILTHE.

Prenez une chaîne de lettres majuscules (AZ) et comptez le nombre de lignes dans les lettres FILTHE, en générant le nombre entier résultant.

E, F, H, I, L, Et Tont 4, 3, 3, 3, 2 et 2 lignes , respectivement.

Par exemple, GEOBITS4 + 3 + 2 = 9 lignes font-elles partie des lettres FILTHE (pour .E..IT.), le résultat devrait donc être 9.

ABCDEFGHIJKLMNOPQRSTUVWXYZdevrait sortir 17.

ABCDGJKMNOPQRSUVWXYZdevrait sortir 0.

FILTHYLINESINLETTERSdevrait sortir 39.

---

Tâche 5 - Alex récursif A.

Notre modérateur Alex A. a une initiale assez mystérieuse, "A".

Maintenant, je ne suis pas certain, mais je pense que cela A.signifie .A xelA. Et je suis aussi à peu près sûr que .Acela représente furtivement Alex A..

Ainsi, pour obtenir le nom complet d'Alex, nous devons développer les A.'et .A':

Alex A. -> Alex [A.] -> Alex [.A xelA] -> Alex .A xelA -> Alex [.A] xelA -> Alex [Alex A.] xelA -> Alex Alex A. xelA -> etc.

Demandez à votre programme de prendre un entier non négatif et de le développer Alex A.plusieurs fois, en générant la chaîne résultante.

Ainsi
0deviennent Alex A.,
1deviennent Alex .A xelA,
2deviennent Alex Alex A. xelA,
3deviennent Alex Alex .A xelA xelA,
4deviennent Alex Alex Alex A. xelA xelA,
5deviennent Alex Alex Alex .A xelA xelA xelA,
et ainsi de suite.

^{(J'ai fait cela parce que je me sentais mal d'avoir laissé Alex par inadvertance en dehors de mon défi hommage mod .: P)}

---

Tâche 6 - Rotation du pavé numérique

Prenez un entier de 1 à 9 inclus (vous pouvez le prendre comme une chaîne). Affiche le carré 3 × 3 de chiffres

789
456
123

tourné par incréments de 90 ° de sorte que le chiffre saisi apparaisse n'importe où sur la rangée supérieure. Quand 5est entrée, toute rotation est une sortie valide car il est 5impossible de faire pivoter vers le haut.

par exemple quand 3est entrée, les deux

963
852
741

et

321
654
987

sont des sorties valides.

Pour entrée 4seulement

147
258
369

est une sortie valide.

---

Tâche 7 - Scinder les chiffres en dizaines

Prenez une chaîne non vide de chiffres décimaux (0-9) et indiquez une valeur de vérité si elle peut être scindée en sections contiguës où tous les chiffres de chaque section totalisent exactement 10. Si cela n'est pas possible, indiquez une valeur de fausseté.

par exemple, 19306128peuvent être scindés de la manière suivante 19|3061|28: les sections totalisant toutes 10 (1 + 9, 3 + 0 + 6 + 1, 2 + 8), une valeur de vérité doit donc être sortie.

Exemples de vérité (un par ligne):

19306128
073
730
0028115111043021333109010
2222255

Exemples de fausseté:

6810410
9218
12341
5222225
000

---

Tâche 8 - Horloge carrée

Prenez une chaîne multiligne de taille constante.

Sortie 12si l'entrée est

 _ _
| | |
|_ _|

Sortie 3si l'entrée est

 _ _
| |_|
|_ _|

Sortie 6si l'entrée est

 _ _
| | |
|_|_|

Sortie 9si l'entrée est

 _ _
|_| |
|_ _|

Il n'y a pas d'autres cas d'entrée.

---

Tâche 9 - Art du support

Prendre dans une chaîne de 4 octets contenant l' un de chacun des supports de gauche (, [, {, et <dans un ordre quelconque.

Ajoutez les crochets droits correspondants pour que la chaîne ait une longueur de 8 octets et une ligne de symétrie verticale. par exemple [<({devient [<({})>].

Inversez ensuite tous les crochets de cette chaîne. par exemple [<({})>]devient ]>)}{(<[.

Affiche la chaîne de 8 octets d'origine avec la version inversée en haut et en bas sur des lignes séparées.

Donc, le résultat final pour l'entrée [<({serait

]>)}{(<[
[<({})>]
]>)}{(<[

De même, la sortie pour <({[devrait être

>)}][{(<
<({[]})>
>)}][{(<

L'entrée (<<[est invalide car il {manque et il y a un extra <.

---

Tâche 10 - Périmiterise

Prenez une grille rectangulaire de texte (1 × 1 au plus petit) constituée de .'s représentant des espaces vides et de X' qui représentent des carreaux pleins. Les cellules situées au-delà des limites de la grille sont considérées comme vides. Vous pouvez supposer que chacune des 4 lignes et colonnes du bord de la grille en contient au moins une X.

Par exemple, une entrée valide pourrait être:

XXX.....X.....
X..X...X.X....
XXX.....X....X

Générez une autre grille de texte rectangulaire dans laquelle toutes les cellules vides adjacentes à une Xorthogonale ou diagonale, y compris celles situées en dehors de la grille de saisie , deviennent o. Donc, essentiellement, un périmètre de o'est dessiné autour de toutes les portions de carreaux pleins. La nouvelle grille ne devrait pas être plus grande que nécessaire.

Ainsi, le résultat de l'exemple ci-dessus serait:

ooooo...ooo.....
oXXXoo.ooXoo....
oXooXo.oXoXo.ooo
oXXXoo.ooXoo.oXo
ooooo...ooo..ooo

De même, la sortie d’entrée XXX..X.Xdevrait être

oooooooooo
oXXXooXoXo
oooooooooo

et sortie

oooooooooo.
oXXXooXoXo.
oooooooooo.

serait invalide puisque la colonne la plus à droite vide est inutile.

Vous pouvez utiliser tous les 3 distincts ASCII imprimables caractères à la place ., Xet o.

---

Tâche 11 - Place Sator

Sortez le carré Sator :

SATOR
AREPO
TENET
OPERA
ROTAS

N'importe laquelle des lettres peut être en minuscule ou en majuscule, donc

SatOR
aRePO
tenet
OPERa
RoTaS

est également une sortie valide.

Il n'y a pas d'entrée.

---

Tâche 12 - Prime Tweet

Ne faites aucune entrée, mais générez une chaîne ASCII imprimable de 140 octets contenant au moins un de chacun des 95 caractères ASCII imprimables. (Donc, 45 caractères seront des doublons.)

La somme des codes de caractère de tous les 140 octets de cette chaîne doit être un nombre premier de Sophie Germain , c’est-à-dire un nombre premier ptel qu’il 2p+1soit également premier. Le code de caractère pour l'espace est 32, 33 pour !, 34 pour ", et ainsi de suite jusqu'à 126 pour ~. La somme pourrait être calculée en Python comme sum(map(ord, myString)).

Un exemple de sortie est:

! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

La somme de code de caractère est le nombre premier 12203 dont le nombre premier sûr est 24407.

Pyth, 9 tâches en 136 octets

Tâche 1: 7 octets

<-F_SQ0

Manifestation

Triez par ordre décroissant ( _SQ), repliez la soustraction sur eux ( a-b-c), vérifiez si le résultat est négatif.

Tâche 2: 14 octets

sho.a-sN^T6.pz

Manifestation

Formez toutes les permutations de chaînes ( .pz), triez-les ( o) en fonction de la valeur absolue de la différence ( .a-) entre le nombre ( sN) et un million ( ^T6).

Prenez la première chaîne de ce type ( h) et convertissez-la en num. ( s)

Tâche 4: 19 octets

s/L+\EPP*3"EFHILT"z

Manifestation

Répliquez "EFHILT"trois fois ( *3), supprimez la fin LT( PP) et ajoutez un E( +\E). Mappez chaque lettre de l'entrée sur son nombre d'apparences dans cette chaîne. ( /L ... z) Somme. ( s)

Tâche 5: 16 octets

u+"Alex "_GhQ".A

Manifestation

En commençant par "A.", inversez et ajoutez un "Alex "au début, entrez + 1 fois.

Tâche 7: 13 octets

}Y-RTsMM./sMz

Convertissez la chaîne d'entrée en une liste de nombres à 1 chiffre ( sMz). Former toutes les partitions ( ./). Somme chaque élément de chaque partition ( sMM). Supprimez tous les 10 de chaque sous-liste ( -RT). Vérifiez si cette sous-liste est vidée en vérifiant si la liste vide figure dans la liste globale ( }Y).

Tâche 8: 11 octets

*3h%%CQC\Ç4

Manifestation

Magie modulo. Convertissez en nombre ( CQ), prenez le mod 199 ( C\Ç= 199) et prenez le mod 4. Ensuite, ajoutez 1 et multipliez par 3.

Tâche 9: 21 octets

J+Xz"<{[()]}>")_zJ_JJ

Manifestation

Premièrement, nous générons la première ligne, qui comprend l’entrée traduite en caractères miroir ( Xz"<{[()]}>")), suivie de l’entrée inversée ( + ... _z), et l’enregistrons dans J. Puis imprimez cette ligne, son verso et cette ligne à nouveau ( J_JJ).

Tâche 11: 22 octets

+J"SATOR
AREPO
TEN"t_J

Manifestation

Imprimez simplement une chaîne et son inversion, mais ne dupliquez pas le centre N.

Tâche 12: 13 octets

++G*19\3srd\

Manifestation

Il y a un caractère invisble DEL( 7F) à la fin du code.

Cela imprime

abcdefghijklmnopqrstuvwxyz3333333333333333333 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

qui a la somme de caractère 11321. Il comprend Gl'alphabet, le 19 3s et tous les caractères ASCII imprimables.

CJam, 8 9 tâches sur 140 octets

Tout d'abord, voici un script que vous pouvez utiliser pour trier vos solutions et vous indiquer celles qui s'intégreront dans le tweet:

{\s\Se[oSo}:F;
qN/ee{W=,}${)_,_T+:T140>X*_{0:X;}*'=@11+*N+*o\~)YF_,ZFTZFoNo}/

Collez simplement vos 12 solutions dans l’entrée, une sur chaque ligne. Exécutez-le ici. La première colonne est le numéro de la tâche, la seconde sa taille (en caractères - vous devrez la corriger vous-même si elle diffère du nombre d'octets), la troisième la taille cumulée. Les programmes qui entrent dans le tweet sont séparés du reste par une ligne de ===.

Pour moi, le résultat ressemble à ceci:

 1   7   7 q~$~\->
 8  10  17 qDbJ%5/)3*
12  12  29 ',32>_51>'d
 7  13  42 Aq{~-Ace|}/N&
 2  15  57 qe!{~1e6-z}$0=~
 4  19  76 q"FIHEELT"3*H<fe=:+
 5  20  96 ".A"q~){" xelA"+W%}*
 9  22 118 q_{_')>+)}%W%+_W%N@N3$
11  22 140 "SATOR\AREPO\TEN"_W%1>
====================================
 6  25 165 9,:)s3/zq~))3mdg*{W%z}*N*
 3  43 208 LLq{_'=-z({+}{'=>_)$\[{)@+\}{\(@\+}]=&}?}/\
10  45 253 0XW]_m*qN/{'.f+W%z}4*f{\~@m>fm>N*}(\{8f^.e>}/

Voici donc les tâches que je peux actuellement intégrer dans le tweet.

Tâche 1 - Trois nombres peuvent-ils former un triangle? - 8 7 octets

Merci à jimmy23013 d’avoir économisé 1 octet.

q~$~\->

Suite de tests.

L'entrée devrait être une liste de type CJam.

C'est assez simple: vérifiez si le plus grand côté est plus court que la somme des deux autres. Ou, de manière équivalente, vérifiez que le côté le plus court est plus long que la différence des deux autres:

q~  e# Read and eval input.
$~  e# Sort the values and dump them on the stack.
\-  e# Subtract the middle value from largest.
>   e# Check if the smallest value is greater than that.

Tâche 2 - Plus proche du million - 15 octets

qe!{~1e6-z}$0=~

Suite de tests.

Force brute simple:

q        e# Read input.
e!       e# Get all permutations.
{        e# Sort by...
  ~      e#   Evaluate the permutation to get its numerical value X.
  1e6-z  e#   abs(X - 1,000,000)
}$
0=       e# Pick the first element (which minimises the difference)
~        e# Evaluate it to get rid of the leading zeroes.

Tâche 4 - Lettres FILTHE - 21 19 octets

Merci à jimmy23013 pour la sauvegarde de 2 octets.

q"FIHEELT"3*H<fe=:+

Suite de tests.

L'idée est de créer une chaîne contenant chacune des lettres FILTHE une fois pour chacune de leurs lignes orthogonales. Cela se fait via une drôle de manipulation de chaîne:

q          e# Read the input.
"FIHEELT"  e# Push this string. It first contains the 3-line letters, then the 2-line 
           e# letters, where we include 'E' twice to make it count for 4.
3*         e# Repeat 3 times: "FIHEELTFIHEELTFIHEELT"
H<         e# Truncate to 17 characters: "FIHEELTFIHEELTFIH". This is chosen such that
           e# it discards the third repetition of the 2-line letters.
fe=        e# For each character in the input, count its occurrences in this new string.
:+         e# Sum them all up.

Tâche 5 - Alex récursif A. - 27 à 20 octets

".A"q~){" xelA"+W%}*

Suite de tests.

La mise en œuvre directe A.et .Adirecte est beaucoup trop coûteuse. Au lieu de cela, nous remarquons que nous n'avons à gérer qu'un cas, si nous inversons la chaîne à chaque fois. De plus, ajouter Alexun préfixe (et un espace) équivaut chaque fois à agrandir l’initiale. Nous pouvons sauvegarder un autre octet en ajoutant l'inverse avant d'inverser la chaîne:

".A"        e# Start with ".A" (the -1st iteration if you like).
q~)         e# Read input, eval, increment (so the following block is run at least once.)
{           e# Repeat this block that many times...
  " xelA"+  e#   Append " xelA".
  W%        e#   Reverse the string.
}*

Tâche 7 - Fractionnement des chiffres en dizaines - 18 16 13 octets

Aq{~-Ace|}/N&

Suite de tests. (Avec des crochets autour de chaque sortie.)

Pas vraiment convivial: la valeur de vérité est une nouvelle ligne, la valeur de faux est la chaîne vide.

L'idée de base est simple: ajoutez les chiffres à un total cumulé que nous réinitialisons chaque fois qu'il frappe exactement 10. Le total doit être égal à zéro à la fin de la saisie. Pour commencer, il s'avère être plus court que le total à 10 et soustrayez les chiffres, en réinitialisant le total chaque fois que vous atteignez 0. Cependant, nous devons nous assurer que nous ne retournons pas quelque chose de vrai lorsque l'entrée est entièrement à zéros. Le moyen le plus rapide que j'ai trouvé était de réinitialiser le total au caractère avec le point de code 10 (le saut de ligne), puis de vérifier à la fin que nous avions ce caractère sur la pile, et non le nombre 10. Cela fonctionne, parce que le nombre entier zéro et le caractère zéro (l'octet nul) sont faux:

A     e# Push a 10, the initial running total.
q{    e# For each character in the input...
  ~-  e#   Evaluate the character to get the digit and subtract it from the total.
  Ac  e#   Push a linefeed character.
  e|  e#   Logical OR of the running total and the linefeed character (using
      e#   short-circuiting).
}/
N&    e# Take the set intersection with the string containing a linefeed character.
      e# If the total is still a number of any character other than the linefeed,
      e# this will yield an empty string. Otherwise, the string will remain unchanged
      e# and the linefeed will be printed.

Tâche 8 - Horloge carrée - 10 octets

qDbJ%5/)3*

Suite de tests.

Ceci est juste une sorte de magie modulo assez aléatoire sur les codes de caractères qui arrive à hacher les valeurs correctes. Je suis assez convaincu que quelque chose de plus court est possible, mais c'est le plus court que j'ai trouvé (par programmation) pour ce type de structure:

q   e# Read the input.
Db  e# Treat the character codes of the string as digits in base 13. This maps the
    e# four inputs to the values: 2023940117708546863
    e#                            2023940113755405840
    e#                            2023940781838850791
    e#                            2023940113755390292
J%  e# Take the result modulo 19. This gives [2, 5, 12, 18], respectively.
5/  e# Divide by 5 (rounding down). [0, 1, 2, 3], respectively.
)   e# Increment. [1, 2, 3, 4], respectively.
3*  e# Multiply by 3. [3, 6, 9, 12], respectively.

Tâche 9 - Art du support - 23 22 octets

Merci à Sp3000 d’avoir économisé 1 octet.

q_{_')>+)}%W%+_W%N@N3$

Suite de tests.

Assez simple. Le mappage entre les crochets gauche et droit se fait en ajoutant 2 (ou 1 pour les parenthèses):

q_      e# Read input and duplicate.
{       e# Map this block onto each character...
  _')>  e#   Duplicate and check if it's not a parenthesis.
  +     e#   Add the result, leaving parentheses unchanged and incrementing the
        e#   other bracket types.
  )     e#   Increment again.
}%
W%+     e# Reverse and add to the original, giving the middle line.
_W%     e# Duplicate and reverse, giving the first line.
N@      e# Push a linefeed, pull up the middle line.
N3$     e# Push another linefeed, copy the first line.

Tâche 11 - Place Sator - 22 octets

"SATOR
AREPO
TEN"_W%1>

Testez-le ici.

Probablement la solution la plus ennuyeuse de toutes. Il pousse la première moitié de la chaîne puis l'inverse:

"SATOR
AREPO
TEN"    e# Push everything up to the centre of the square.
_W%     e# Duplicate and reverse.
1>      e# Discard the "N", because we don't want that twice.

Tâche 12 - Prime Tweet - 13 12 octets

',32>_51>'d

Testez-le ici. (Avec sortie de diagnostic pour le résultat.)

Après 'il y a le unprintable <DEL>(0x7F), que SE élimine . Pour copier-coller, utilisez plutôt cette version:

'~),32>_51>'d

La chaîne imprimée est

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

C'est-à-dire qu'il contient une série de tous les caractères, suivie d'une autre série allant de Sà ~, suivie d'un seul d. La somme des codes de caractères est 12203. J'ai trouvé cela par quelques essais et erreurs.

'~),32>  e# Push a string with all printable characters.
_51>     e# Duplicate this and discard the first 51 of them.
'd       e# Push a "d".

Pyth, 9 tâches en 138 octets

Cela a pris un certain temps.

Je pense que 9 tâches est la limite pour Pyth. L'inclusion du prochain programme le plus court (Sator Square) donne 160 octets. Jouer au golf 20 octets est assez improbable. Il y a 2 ou 3 tâches qui sont un peu laides et qui peuvent peut-être être raccourcies, mais dans l'ensemble, je suis assez satisfait des solutions.

Tâche 1 - Trois nombres peuvent-ils former un triangle ?, 8 octets

>FsMc2SQ

Essayez-le en ligne: Entrée régulière ou Suite de tests

Tâche 2 - Plus proche du million, 14 octets

ho.a-^T6NsM.pz

Essayez-le en ligne: Entrée régulière ou Suite de tests

Tâche 4 - Lettres FILTHE, 20 octets

s*Vtsmmdd5/Lz"TLIHFE

Essayez-le en ligne: Entrée régulière ou Suite de tests

Tâche 5 - Alex récursif A., 16 octets

u+"Alex "_GhQ".A

Essayez-le en ligne: Entrée régulière ou Suite de tests

Tâche 6 - Rotation du pavé numérique, 20 octets

jeo}zhN.uC_N3_c3jkS9

Essayez-le en ligne: Entrée régulière ou Suite de tests

Tâche 7 - Fractionnement des chiffres en dizaines, 15 octets

qTu+WnGTvHG-zZZ

Essayez-le en ligne: Entrée régulière ou Suite de tests

Tâche 8 - Horloge carrée, 12 octets

*3%%Cz1978 5

Essayez-le en ligne: Entrée régulière ou Suite de tests

Tâche 9 - Bracket Art, 20 octets

V3_WtN+z_Xz"[<({})>]

Essayez-le en ligne: Entrée régulière ou Suite de tests

Tâche 12 - Prime Tweet, 13 octets

++*d44srd\\&

Essayez-le en ligne: Entrée régulière

TI-BASIC, 11 12 tâches dans 728 830 octets

Tâche 1 en 7 octets

:2max(Ans)`<`sum(Ans

L'entrée est une liste dans Ans.

Tâche 2 dans 92 à 110 octets

:seq(expr(sub(Ans,I,1)),I,1,7→L₁
:SortA(L₁
:min(7,1+sum(not(L₁
:{L₁(1)+sum(seq(L₁(I))₁₀^(I-8),I,2,7)),L₁(Ans)+sum(seq((I`>`Ans)L₁(I)₁₀^(1-I),I,2,7
:ᴇ6Ans(1+(0`>`min(ΔList(abs(1-Ans

Demande une liste de chiffres L' entrée est une chaîne dansAns .

Tâche 3 en 119 octets

:Input Str1
:"  →Str2
:For(I,1,length(Str1
:sub(Str1,I,1→Str3
:inString("`<>`",Ans
:If Ans:Then
:max(0,min(L,C+2Ans-3→C
:Else
:C+1→C
:L+1→L
:sub(Str2,1,C)+Str3+sub(Str2,C+1,L-C+1→Str2
:End
:End
:sub(Str2,2,L

Invite une chaîne. Suppose que C et L sont indéfinis ou 0.

Tâche 4 en 35 octets

:sum(int(2seq(inString("TLIHFE",sub(Ans,I,1))^.4,I,1,length(Ans

L'entrée est une chaîne dans Ans .

Tâche 5 en 63 octets

:Ans/2→C
:sub("A.A",1+2fPart(C),2
:For(I,0,C
 :"Alex "+Ans
 :If I≠C
  :Ans+" xelA
:End
:Ans

L'entrée est un nombre en Ans .

Tâche 6 en 66 octets

: 𝑖 ^ ((Ans <7) (Ans-3 (Ans> 3: Pour (Y, ,11,1: Disp sum) (seq ((5-real (AnsX + AnsY) -3imag (AnsX + Ans𝑖Y))) ₁₀ ^ ( X + 1), X, ⁻1,1: fin

L'entrée est un nombre en Ans .

Tâche 7 en 36 43 octets

:Input <strike>L₁</strike>Str1
:.5
:For(I,1,<strike>dim(L₁</strike>length(Str1
 :Ans+<strike>L₁(I</strike>expr(sub(Str1,I,1
 :If 10=int(Ans
  :0
:End
:not(Ans

Invite pour une liste de chiffres chaîne .

Tâche 8 sur 29 octets

:18fPart(sum(seq(I(sub(Ans,I,1)=" ")/6,I,1,15

L'entrée est une chaîne dans Ans .

Tâche 9 en 83 octets

:For(I,1,16,2
 :If I<8
  :Ans+sub("`)}]>`",inString("`({[<`",sub(Ans,4,1)),1
 :sub(Ans,I,1)+Ans
:End
:For(I,⁻1,1
 :Disp sub(Ans,9-8abs(I),8
:End

L'entrée est une chaîne dans Ans .

Tâche 10 en 159 octets

:1→X
:Input Str1
:2+length(Str1→L
:"X
:While 2+L`>`length(Ans
 :Ans+Ans→Str2
:End
:Ans→Str3
:While 1
 :"XX
 :Ans+Str1+Ans→Str1
 :For(I,1,L
  :Ans+sub("0X.",2expr(sub(Str2,I+1,1))+not(expr(sub(Ans,I,3)+sub(Str2,I,3)+sub(Str3,I,3))),1
 :End
 :Disp sub(Ans,L+3,L
 :Str2→Str3
 :Str1→Str2
 :Input Str1
:End

Utilise X0.au lieu de .Xorespectivement (désolé rien ne correspond). Invite à entrer ligne par ligne. Vous devez entrer deux lignes deX s pour voir toute la sortie, puis 2nd + Quit pour quitter.

Tâche 11 en 39 octets

:Disp "SATOR
:Disp "AREPO
:Disp "TENET
:Disp "OPERA
:Disp "ROTAS

Tâche 12 en 77 octets

: Ans + "tvm_I% LinReg (ax + b) DS <(getKeyconj (1-PropZTest (dayOfWk (Manual-Fit C / YANOVA), rangée), rangée (HorizRegEQUnarchive [J]! # $ &'', .234567890:; = >? @GBQX \^). _`qw {|} ~

Ou en tant qu'hex:

72702ABB21FFDBADBB25BB3EEF06EF16
6331BB5917746201BB695C092DBBD2BB
D3BBD4AEAE2B3A323334353637383930
3EBBD66A6CAFBBD147425158BBD7F0BB
D9BBD5BBC1BBC708BBD809BBCF

L'entrée est une chaîne contenant "dans Ans.

C'est en fait impossible dans TI-BASIC. Il est possible d'éditer un programme de base au format hexadécimal et d'utiliser certains jetons de 2 octets pour obtenir tous les caractères ASCII imprimables dans le code source, mais ce n'est pas le problème. Le problème est qu’il n’ya aucun moyen de stocker un "caractère dans une chaîne en mode de base pur sur un calcul clair sans entrée de programme (la même chose s’applique au →caractère, mais ce n’est pas une ascii imprimable). Il est toutefois possible de placer "une équation en dehors de base, après quoi vous pouvez utiliser basic pour convertir l'équation en chaîne et afficher cette chaîne. En plus de tout cela, il n’ya que suffisamment d’espace à l’écran pour 128 caractères à la fois.

Perl, 4 tâches sur 117 octets

Essayons une vraie langue;)

Je n'ai pas encore abandonné, je pourrais même être capable de compresser 5 tâches sur 140 octets, bien que cela soit peu probable!

* Tâche 1: 30 + 1 = 31 octets

@F=sort@F;say$F[0]+$F[1]>$F[2]

Usage: perl -aM5.010 entry.pl input.txt

* Tâche 4: 32 + 1 = 33 octets

y/ELTFHI/4223/;s/./+$&/g;$_=eval

Usage: perl -p entry.pl input.txt

Tâche 5: 54 octets

say"Alex "x($_/2+1).qw(A. .A)[$_%2]." xelA"x(--$_/2+1)

-2b grâce à Dom Hastings

Usage: echo 4 | perl -M5.010 entry.pl

Tâche 7: 37 + 2 = 39 octets

($i+=$_)>10&&exit,$i%=10for@F;$_=!$i;

Usage: perl -pF entry.pl input.txt

* Tâche 8: 21 + 2 = 23 octets

$_=y/|_ 
/14/dr/64%14

C'est un peu délicat. Commencé en remplaçant chaque |avec xet chacun _avec yensuite le remplacement des espaces pour produire une chaîne à deux chiffres unique pour chaque grille ( yyxxyxxyyx, yyxxyxxyyxyyxxxxyxyx,yyxxxxyxyxyyxyxxxyyx , yyxyxxxyyxyyxxxxyyx, yyxxxxyyx). Ensuite, j'ai écrit un programme pour définir les valeurs bruteforce pour xet y, ainsi que des opérations mathématiques pouvant être effectuées sur les nombres produits après la substitution xet ypour donner un résultat de 3,6,9,12 pour chaque nombre. En fin de compte , x=1, y=4et l'opération de la magie était /64%14.

Usage: perl -0p entry.pl input.txt

Tâche 11: 34 octets

say"SATOR
AREPO
TENET
OPERA
ROTAS"

Usage: perl -M5.010 entry.pl

* Tâche 12: 30 octets

say d.pack"C*",32..126,83..126

Usage: perl -M5.010 entry.pl

Avertissement: -M5.010 est considéré comme "gratuit"

Ruby, 4 tâches sur 280 octets (non compétitif)

Ceci est juste une tentative, je continuerai à faire des tâches plus tard (et j'espère jouer au golf avec celles existantes).

Tache 1

a=gets.split.map &:to_i;p a.all?{|e|e<a.inject(:+)-e}

Tâche 2

p gets.chars.permutation.map{|a|a.join.to_i}.min_by{|x|(x-1e6).abs}

Tâche 4

n,b='EFHILT',0;gets.chars.map{|c|b+=n[c]==p ? 0:[4,3,3,3,2,2][n.index c]};p b

Tâche 5

a='Alex A.';gets.to_i.times{|i|i%2<1 ? a.sub!('A.','.A xelA'):a.sub!('.A',a)};$><<a

TI-BASIC, 12 tâches en 994 octets

Télécharger tout sous forme de fichier de groupe TI ( .8xg )

(Tags spoiler ajoutés par demande.)

Tâche 1 - Trois nombres peuvent-ils former un triangle? - 7 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:2max(Ans)<sum(Ans

Tâche 2 - Plus proche du million - 114 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:int(10fPart(Ans\10^(\-cumSum(binomcdf(6,0→X
:"sum(\L\X\10^(\cumSum(not(binompdf(6,0→\Y1\
:SortD(\L\X
:\Y1\→X
:sum(not(\L\X
:If Ans
:Then
:If max(\L\X=1
:X+\E\6-\10^(\6-Ans→X
:SortA(\L\X
:augment(ΔList(cumSum(\L\X)),{0→X
:End
:{X,\Y1\
:Ans(1+(0>min(ΔList(abs(\E\6-Ans

Tâche 3 - Simulateur de clavier simple - 131 à 127 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:Input Str1
:DelVar X1→Y
:"..→Str2
:For(Z,1,length(Str1
:sub(Str1,Z,1→Str3
:(Ans=">")-(Ans="<
:If Ans
:Then
:max(1,min(Y+Ans,X+1→Y
:Else
:sub(Str2,1,Y)+Str3+sub(Str2,Y+1,X-Y+2→Str2
:X+1→X
:Y+1→Y
:End
:End
:sub(Str2,2,X

Tâche 4 - Lettres FILTHE - 34 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:sum(int(\³√(\12seq(inString("TLIHFE",sub(Ans,X,1)),X,1,length(Ans

Tâche 5 - Alex récursif A. - 107 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:Input X
:".A..
:For(X,0,X
:Ans→Str1
:5int(.5X+.5
:sub(Str1,1,Ans+1)+sub(".A xelAlex A.",6gcd(X,2)-5,7)+sub(Str1,Ans+4,5X-Ans+1
:End
:sub(Ans,2,5X+2

Tâche 6 - Rotation du pavé numérique - 86 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:.3Ans+2(Ans=6→X
:[[9,6,3][8,5,2][7,4,1
:For(X,0,X
:rowSwap(Ans\^T\),1,3
:End
:Ans
:*row+(10,*row+(10,Ans\^T\,1,2),2,3
:For(X,1,3
:Disp Ans(3,X
:End

Tâche 7 - Scinder les chiffres en dizaines - 77 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:Ans+"0
:seq(expr(sub(Ans,X,1)),X,1,length(Ans
:augment(Ans,{10not(not(max(Ans→X
:1→X
:Repeat Ans≥dim(\L\X
:Ans+1
:If 10=sum(\L\X,X,Ans
:Ans+1→X
:End
:X=Ans

Tâche 8 - Horloge carrée - 35 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:12-3max(seq(X(sub(Ans,6gcd(X,2)+X,1)≠" "),X,1,3

Tâche 9 - Bracket Art - 86 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:Input Str1
:For(X,1,4
:For(Y,0,1
:abs(X-9not(Y→Z
:"()[]{}<>
:sub(Ans,inString(Ans,sub(Str1,X,1))+Y,1
:Output(1,Z,Ans
:Output(2,9-Z,Ans
:Output(3,Z,Ans
:End
:End

Tâche 10 - Périmiterise - 218 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:".
:For(A,0,\E\9
:Input Str1
:Ans+Str1→Str2
:If Str1≠".
:End
:length(Ans→X
:round(A\^-1\(Ans-2→B
:seq(expr(sub(Str2,A,1)),A,2,X-1→B
:πAns→C
:"augment(Ans,augment(Ans,\L\B))+augment(Ans,augment(\L\C,Ans))+augment(\L\B,augment(Ans,Ans→X
:seq(0,A,1,B
:\L\X→A
:For(C,0,A+1
:seq(\L\A(A+BC),A,1,B→C
:int(Ans→B
:{0
:1+not(\L\X)+not(fPart(\L\X→B
:".
:For(X,1,B+2
:Ans+sub("120",\L\B(X),1
:End
:Disp sub(Ans,2,B+2
:End

Ces substitutions ont été faites: 0= ., 1= X, 2=o

Pour la saisie (après le début du programme), tapez une ligne à la fois, en appuyant sur Entrée à chaque changement de ligne, jusqu'à ce que la dernière ligne soit écrite. Ensuite, appuyez sur Entrée, tapez un point, puis appuyez à nouveau sur Entrée pour soumettre la chaîne entière.

Tâche 11 - Place Sator - 38 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:Disp "SATOR","AREPO","TENET","OPERA
:"ROTAS

Tâche 12 - Prime Tweet - 151 octets

Télécharger sous forme de fichier de programme TI-83 + ( .8xp )

:Ans+"!#$%&'()*+,-./01234567889:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
:For(X,1,45
:Ans+" 
:End
:Ans

Ansdevrait contenir un guillemet double, effectué en en tapant un directement dans \Y1\l'éditeur d'équation et en partant Equ►String(\Y1\,Str1:Str1de l'écran d'accueil.

La longueur de sortie est 140. 8 apparaît deux fois et il y a 45 espaces avec les autres caractères ASCII qui apparaissent chacun une fois. Cela équivaut à (33 + 34 + ... + 126) + 56 + 32 × 45 = 8969, un nombre premier de Sophie Germain.

Python 3, 1 tâche, 268 octets, non compétitif

J'ai essayé la tâche n ° 2 dans Python 3.5.2. Je suis nouveau dans le domaine du golf et du python.

import itertools
def f2(l):
    n=1000000
    l=list(itertools.permutations(l))
    j = len(l)
    m=[None]*j
    while j>0:
        j -= 1
        m[j]= int(''.join(str(i) for i in l[j]))
        l[j]=abs(n-m[j])
    l.sort()
    k=n-l[0]
    return(n+l[0],k)[k in m]