les tâches

Tous les concurrents tentent de résoudre la liste suivante de 10 tâches:

math

1. Lit un entier positif n à partir de l’entrée et renvoie la somme des cubes des n premiers entiers non négatifs.

   Pour entrée 1, cela devrait revenir 0.

2. Lit un entier positif n à partir de l'entrée et renvoie une valeur de vérité si et seulement si n est un nombre premier de Mersenne .

3. Lire une liste non vide de n entiers à partir de l'entrée et renvoyer leur médiane .

   Si n est pair, utilisez la moindre des deux valeurs centrales.

   Par exemple, la médiane de [1 4 3 2]is 2.

4. Lit un entier (positif, négatif ou 0), ou une représentation sous forme de chaîne en base 10 ou unaire, à partir de l'entrée et renvoie ses chiffres en négatif , sans zéros (à l'exception de l'entrée 0).

   La sortie peut être formatée de toute manière pratique (chiffres, tableau, chaîne, etc.).

chaîne

5. Retour pneumonoultramicroscopicsilicovolcanoconiosis.

6. Vérifiez la date du jour et revenez le Happy New Year!cas échéant selon le calendrier grégorien.

7. Sélectionnez de manière pseudo-aléatoire 64 points de code attribués uniques dans le bloc Unicode CJK Unified Ideographs Extension-A (U + 3400 - U + 4DB5) et renvoyez la chaîne des caractères correspondants.

   Toutes les chaînes possibles doivent avoir la même probabilité d'être sélectionnées.

8. Lire deux chaînes de caractères ASCII imprimables depuis l'entrée et renvoyer une valeur de vérité si et seulement si le caractère de la première chaîne forme une sous-séquence de la deuxième chaîne.

   Par exemple, abc, axbxcdevrait revenir truthy et bac, axbxcdevrait revenir falsy.

manipulation de tableau

9. Lire un tableau rectangulaire multidimensionnel d'entiers et un entier n à partir de l'entrée et renvoyer le tableau modifié avec tous les entiers multipliés par n .

ascii-art

10. Lire un entier non négatif n à partir de l'entrée et renvoyer une chaîne de n wagons, comme indiqué ci-dessous.

    Exemple de sortie pour n = 3 :

     ______   ______   ______ 
    |      | |      | |      |
     ()--() ~ ()--() ~ ()--()
    

    La sortie peut être entourée d'une quantité quelconque d'espaces blancs, à condition que cela ressemble à l'exemple.

Des clarifications

• 0 n'est ni positif ni négatif.

• Les espaces de fin sont toujours autorisés dans la sortie.

• Plusieurs entrées peuvent être lues dans n'importe quel ordre cohérent et commode.

Règles

1. Aucune réponse ne peut résoudre deux tâches différentes dans le même langage de programmation. ¹

2. Les règles standard de code-golf s'appliquent à chaque tâche .

   En particulier, vous pouvez soumettre des programmes ou des fonctions avec les valeurs par défaut d'E / S habituelles , mais vous ne pouvez pas tirer parti de ces lacunes .

   La tâche 5 est essentiellement un défi de complexité kolmogorov , donc le codage en dur de la sortie est non seulement autorisé, mais attendu.

3. Une seule réponse par utilisateur doit être publiée, contenant au plus une solution pour chacune des tâches.

   Veuillez formater votre réponse comme dans l'exemple suivant:

   ## Task 1, Python, 42 bytes
   
       <code goes here>
   
   Explanation, I/O, required Python version, etc. go here.
   
   ---
   
   ## Task 7, C, 42 bytes
   
       <code goes here>
   
   Explanation, I/O, required compiler (flags), etc. go here.
   

Notation

1. Pour chaque tâche que vous résolvez, vous obtenez un point.

   Cela signifie que vous n'avez pas à résoudre toutes les tâches pour participer.

2. Si votre solution pour la tâche n est la plus courte dans ce langage de programmation, vous obtenez un point supplémentaire.

3. Si votre solution pour la tâche n est le plus court de tous les langages de programmation, vous obtenez un point supplémentaire.

4. Les points bonus ne seront attribués qu’une seule fois pour chaque combinaison de tâches / langue et pour chaque tâche, respectivement.

   Comme d’habitude, si deux solutions ont le même nombre d’octets, le temps d’affichage est décisif.

   Si quelqu'un vous gomme plus tard, vous perdez le (s) point (s) de bonus que l'autre répondant gagne.

5. Vous pouvez participer au golf, ajouter / supprimer des langues de votre réponse ou échanger les langues utilisées pour deux tâches.

   Chaque fois que quelqu'un modifie sa réponse, toutes les réponses sont rediffusées.

6. Une fois que vous avez changé de langue pour une tâche, vous perdez votre ancienneté. ²

La réponse avec le score le plus élevé gagne. ³

Classement par tâche

<style>body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}</style><script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><table class=answer-list><thead><tr><td>Task<td>Author<td>Language<td>Score<tbody id=answers></table></div><table style=display:none><tbody id=answer-template><tr><td>{{TASK}}<td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}</table><script>function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function process(){answers.forEach(function(e){var s=e.body_markdown.split("\n").filter(function(e){return"#"==e[0]});s.forEach(function(s){var r=s.match(NUMBER_REG)[0],t=(s.match(SIZE_REG)||[0])[0],a=s.match(LANGUAGE_REG)[1],n=e.owner.display_name;entries.push({task:r,user:n,language:a,size:t})})}),entries.sort(function(e,s){var r=e.task-s.task;return r?r:e.size-s.size});for(var e=0;e<entries.length;e++){var s=jQuery("#answer-template").html();s=s.replace("{{TASK}}",entries[e].task).replace("{{NAME}}",entries[e].user).replace("{{LANGUAGE}}",entries[e].language).replace("{{SIZE}}",entries[e].size),s=jQuery(s),jQuery("#answers").append(s)}}var QUESTION_ID=52152,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*.*?,\s*\[*([^,\]]+)/,entries=[];</script>

Classement combiné (2015-07-30 20:00 UTC)

User / Task      1 2 3 4 5 6 7 8 9 A   TOTAL   Tie breaker (if any)

DLosc            2 2 3 2 2 2 2 3 2 2      22
Sp3000           2 2 2 2 2 3 2 2 2 2      21
Doorknob         2 2 2 2 2 2 2 2 2 2      20
mathmandan       2 2 2 2 2 2 2 2 2 2      20   Combined byte count.
MickyT           2 2 2 2 2 2 1 2 2 2      19
Alex A.          2 1 2 2 2 2 1 2 2 2      18
Jacob            2 2 2 2 2 1 0 0 0 2      13
alephalpha       2 2 2 0 2 2 0 0 2 0      12
Martin Büttner   2 0 0 2 2 0 0 2 2 2      12   Combined byte count.
kirbyfan64sos    1 2 2 0 2 X 0 2 0 3      12   Per-language wins.
Maltysen         3 0 0 0 3 2 1 X 2 0      11
plannapus        2 2 0 0 2 2 0 2 0 2      10
jimmy23013       0 0 2 3 0 0 3 2 0 0      10   Solved tasks.
Tom              0 3 0 0 2 2 0 X 3 0      10   Combined byte count.
FryAmTheEggman   1 0 2 0 2 0 2 0 2 0       9
Vioz-            1 0 2 2 2 2 0 0 0 0       9   Combined byte count.
Toby Speight     2 0 0 0 2 2 0 0 0 2       8
Ismael Miguel    0 0 0 0 2 2 0 0 0 2       6
Pulga            0 2 2 0 0 0 0 0 0 2       6   Combined byte count.
flawr            2 0 2 0 0 0 0 0 0 0       4     
manatwork        2 0 0 0 0 2 0 0 0 0       4   Combined byte count.
TheNumberOne     1 0 0 0 2 0 0 0 0 0       3

Les tâches marquées avec Xsont présentes mais non valides.

Le classement combiné a été construit à la main. S'il vous plaît dites-moi s'il y a des erreurs.

^{1 Les} _{langues sont considérées différentes si elles ne sont pas des versions différentes de la même langue. Il n'y a donc qu'un seul JavaScript, un Python et un TI-BASIC, mais C, C ++, Octave et MATLAB sont quatre langues différentes.}

² _{Si vous résolvez la tâche n en utilisant la langue L en x octets, une autre personne résout la même tâche dans la même langue avec le même nombre d'octets. Vous passez en langue M et annulez votre modification, l'autre répondeur conserve le point bonus.}

³ _{Le nombre de points obtenus avec les règles de notation 1, 2 et 3 (dans cet ordre), le nombre total d'octets combinés de toutes les tâches résolues (plus bas est le nombre de points) et, finalement, le décompte des voix (plus le nombre de points est élevé) sert de départage.}

Tâche 1, GolfScript, 8 octets

~,{+}*.*

Même idée que celle de Martin dans sa réponse.

Tâche 2, QBasic, 74 71 octets

INPUT a
r=a>1
FOR i=2 TO a-1
r=r*(a MOD i)
NEXT
?r*((a\2AND a)=a\2)

Testé sur QB64 avec extension de syntaxe désactivée. ¹ Le gros du programme teste si le nombre donné aest premier en prenant amod chaque nombre 2 <= i< aet en multipliant les résultats. Le résultat est r0 si le nombre n'est pas premier et différent de zéro sinon. La dernière ligne utilise bitwise ANDavec une division entière par 2 pour vérifier si la représentation binaire de aest tout un, c'est a-à- dire de la forme 2 ⁿ -1. Multiplier ceci par rdonne 0 (faux) si un nombre n'est pas un nombre premier de Mersenne et une valeur différente de zéro (vérité) dans le cas contraire. ?est un raccourci pour PRINT.

La plus grande prime de Mersenne que j'ai testée, 8191, donne un résultat de 1.#INF- qui est toujours la vérité! (J'ai vérifié avec une IFdéclaration pour être sûr.)

¹ _{Cela ne change pas la sémantique du programme. Si vous tapez le code ci-dessus dans le DOS QBasic standard, il sera automatiquement mis en forme avec des espaces supplémentaires, mais le résultat sera identique.}

Tâche 3, Pyth, 6 octets

ehc2SQ

Lit une liste de style Python à partir de stdin. La magie principale ici est l' copérateur de saut: donné un int et une liste, il divise la liste en n morceaux. Donc, c2SQcoupe la liste des entrées triées en deux. De manière pratique, lorsque la longueur est impaire, la première moitié est la plus grande, de sorte que la médiane est toujours le dernier élément de la première moitié. C'est le edeuxième du head des résultats de cannibalisation.

Tâche 4, CJam, 26 octets

ri{_2%z\_0>\-2/_3$+?}h;]W%

Cela pourrait être raccourci, je suppose.

Algorithme:

• Lire un entier.
• Do tant que la valeur n'est pas 0:
  • Prenez des abdominaux (i% 2). C'est le chiffre suivant (negabit?).
  • Divise i par -2.
  • Si j'étais non positif, ajoutez abs (i% 2) au résultat. Ceci corrige un cas de coin: 3 va à -1, mais -3 devrait aller à 2, pas 1.
• Supprimez le 0 superflu, collectez la pile dans un tableau, inversez-la et imprimez-la.

Le fait que ce soit une boucle do-while tient compte du cas 0.

Tâche 5, Bash, 50 octets

echo pneumonoultramicroscopicsilicovolcanoconiosis

Pas grand chose à expliquer.

Tâche 6, Python, 78 octets

from datetime import*
d=date.today()
if d.day<2>d.month:print"Happy New Year!"

Requiert Python 2. Les opérateurs d'inégalité d'enchaînement de Python peuvent être bien exploités ici.

Tâche 7, ActionScript, 82 octets

x=""
while(x.length<64){c=chr(13312+random(6582));if(x.indexOf(c)<0)x+=c}
trace(x)

ActionScript fait partie de la famille ECMAScript. Ce code nécessite ActionScript 2, ce qui est bien meilleur pour le code golf, car je peux utiliser des fonctions obsolètes comme chrau lieu de la version 3 String.fromCharCode!

La sortie est dans le volet de la console:

Tâche 8, Pip, 9 à 19 octets

La solution regex ne fonctionnant pas tout à fait, voici donc une solution avec des opérations sur les chaînes.

Fcab@>:o&:(b@?c)+1o

Dépôt Github pour Pip .

Prend les deux chaînes comme arguments de ligne de commande. Quand aest une sous-séquence, sort un entier positif (vérité); sinon, le résultat est nil (falsy), ce qui ne produit aucun résultat.

Explication:

                     Cmdline args -> a,b; o = 1 (implicit)
Fca                  For each character in a:
           b@?c      Find character's index in b (nil if not found)
          (    )+1   Add 1; all possible indices except nil are now truthy
       o&:           Logical AND with o
   b@>:              Slice b to everything at index o and afterward (Python b=b[o:])
                     (If c wasn't found, b becomes nil, but we don't care at that point)
                  o  Auto-print o

Tâche 9, Prolog (SWI), 68 octets

m(L,N,R):-L=[H|T],m(H,N,I),m(T,N,U),R=[I|U];L=[],R=[];R is L*N.

Prolog n’est généralement pas du tout compétitif en code-golf, je suis donc plutôt satisfait de cette solution.

Définit un prédicat m avec des paramètres d'entrée Lpour la liste et Npour le nombre et le paramètre de sortie R. La définition de mest une triple disjonction:

• Si Lpeut être unifié avec [H|T], c’est une liste avec au moins un élément. Appelez mrécursivement en tête et en fin de liste et réassemblez les résultats dans une nouvelle liste unifiée avec R.
• Si Lpeut être unifié avec [], unifiez Ravec []aussi.
• Sinon, Lest supposé être un nombre; L*Nest calculé et affecté à R.

Exemple exécuté avec swiplUbuntu:

dlosc@dlosc:~/golf$ swipl -qs arrayMult.prolog
?- m([1,2,3],5,R).
R = [5, 10, 15] .

?- m([[3,4],[5,6]],3,R).
R = [[9, 12], [15, 18]] .

?- m([[[1,2],[3,4]],[[5,6],[7,8]]],2,R).
R = [[[2, 4], [6, 8]], [[10, 12], [14, 16]]] .

Tâche 10, C, 114 112 106 octets

#define F;printf("\n");for(i=0;i<c;i++)printf(
i;t(c){F" ______  ")F"|      | ")F" ()--() ~");putchar(8);}

Testé avec gccsur Ubuntu. Définit une fonction tqui prend un argument entier. Utilise trois forboucles pour la sortie, fortement condensées via les macro-abus. L’utilisation du caractère de retour arrière pour effacer les ~résultats de fin dans un motif d’espace assez étrange, maisThe output may be surrounded by any amount of whitespace as long as it looks like in the example.

Exemple d'exécution de t(3):

dlosc@dlosc:~/golf$ ./a.out

 ______   ______   ______
|      | |      | |      |
 ()--() ~ ()--() ~ ()--() dlosc@dlosc:~/golf$

Huzzah, d'abord pour terminer toutes les tâches! \ o /

Tâche 1, Perl, 32 octets

$_=eval join"+",map$_**3,0..$_-1

+1 octet pour le -pdrapeau. Commentaire: Perl est bizarre .

Tâche 2, CJam, 14 octets

{_mp\)2mL_i=&}

Mon premier programme CJam!

Tâche 3, GolfScript, 8 octets

~$.,(2/=

Évaluez l'entrée STDIN, triez, prenez la longueur, décrémentez, divisez par deux, puis prenez l'élément du tableau trié à cet index.

Tâche 4, Python, 77 octets

def f(i,d=''):
 while i:i,r=i/-2,i%2;i+=r<0;r+=2*(r<0);d=`r`+d
 return d or 0

Merci à @ mbomb007 pour avoir rasé 24 (!) Octets et à @ Sp3000 pour 11 autres.

Tâche 5, Java, 66 octets

String f(){return"pneumonoultramicroscopicsilicovolcanoconiosis";}

Ennuyeuse. A assommé une langue verbeuse ici pour économiser de la place pour les langues plus golfeuses plus tard.

Tâche 6, Bash, 39 octets

((`date +%j`<2))&&echo Happy New Year\!

Merci à @manatwork de m'avoir parlé de la suppression de %j10 octets dans le processus.

Tâche 7, JavaScript, 148 octets

a=[];Array(65).join('x').replace(/./g,function(){while(a.push(s=String.fromCharCode(13312+Math.random()*6582))&&a.indexOf(s)==s.length-1);return s})

Générez une chaîne de 64 x, puis remplacez-les tous par une fonction de rappel qui retourne un de ces caractères au hasard, si elle ne figure pas déjà dans le tableau des caractères utilisés.

Tâche 8, rouille, 130 octets

fn f(a:String,b:String)->bool{let mut c=b.chars();for x in a.chars(){match c.find(|&y|x==y){Some(_)=>(),None=>return false}};true}

Oui, Rust joue vraiment très mal au golf.

Tâche 9, autruche, 18 octets

{:n;'`\d+`{~n*}X~}

Version 0.7.0 . Inspecte le tableau, remplace-t-on par une expression rationnelle pour remplacer les nombres par leurs versions multipliées, puis évalue à nouveau la chaîne résultante.

Tâche 10, Ruby, 58 octets

->n{([' ______  '*n,'|      | '*n,' ()--() ~'*n]*$/).chop}

"\n"est un caractère plus long que "{actual newline}", ce qui est un caractère plus long que $/. Merci à @ MartinBüttner d’avoir rasé {nombre indéterminé mais grand} octets avec diverses astuces de magie noire.

Tâche 1, 3var, 14 à 13 octets

'><k*>#aa/>sp

( Page wiki Esolang pour 3var )

'                  R = n
 >                 A = n
  <k               B = n-1
    *              R = A*B = n(n-1)
     >             A = n(n-1)
      #aa          B = 2
         /         R = A/B = n(n-1)/2
          >s       A = (n(n-1)/2)^2
            p      Output A

Prend la saisie via un point de code, par exemple, l’espace est 32.

Heureusement, toutes les opérations nécessaires à l’implémentation de la formule n^2 (n-1)^2 / 4sont des caractères uniques (décrémentation, multiplication et quadrature), mais il faut 3 octets pour définir la valeur Bsur 2 (reset-increment-increment).

Tâche 2, Retina, 38 33 octets

^
1
^(..|.(..+)\2+|(.(..)+)\3*)$
<empty>

( Référentiel Github pour Retina )

Chaque ligne est placée dans un fichier séparé, mais vous pouvez tester ce qui précède tel quel avec l' -sindicateur (en le remplaçant <empty>par rien). Les entrées doivent être unaires avec 1, par exemple 1111111pour 7.

Voici ce que fait chaque substitution de regex (spécifiée par une paire de lignes):

1. Attaque d'un 1 supplémentaire à l'avant
2. Remplacez n'importe quoi de la forme 2, 1 + compositeou not power of 2par rien.

Cela ajoute un extra 1aux nombres premiers de Mersenne, tandis que tous les autres nombres sont effacés.

Tâche 3, Raquette, 71 octets

#lang racket
(define(m x)(list-ref(sort x <)(quotient(-(length x)1)2)))

Les langues de type Lisp sont trop verbeuses. Exemple d'exécution:

> (m `(1 3 4 2))
2

Tâche 4,> <>, 31 octets

:?!v:2%:@-02-,
)?~\l1
!;n>l?

( Page wiki Esolang pour> <> )

Ce qui précède est de 28 octets et requiert l’ -vindicateur dans l’interpréteur Python pendant 3 autres octets , par exemple, comme ceci:

$ py -3 fish.py negabinary.fish -v -137
10001011

La bonne chose à propos de> <> ici est que nous pouvons calculer les chiffres un par un via modulo et division, ce qui donne les chiffres dans l’ordre inverse, ce qui est parfait pour imprimer sur une pile.

Tâche 5, Parenthèse, 1448 1386 octets

((()()())(()()()())((()())((()(())()))((()(())(())())((()(()))(()(())())((()(()))((())())((()()(()))((())()()()()()()()())((())()()()()()()()()()()()())))))))((()()())(()()())((()())((()(())()))((()()()())((()(()))(()(())())((())()()()()()()()()()()())))))((()(()))((()()())((())()()()()))((()()())((())()()))((()()()())((())()()()()))((()()())((())()()()()()()()()()))((()()())((())()))((()()())((())()()()))((()()())((())()()))((()()())((())()()()))((()()())((())()()()()()()()()()))((()()())((())))((()()())((())()()()()()()()()))((()()())((())()()()()()()))((()()()())((())))((()()())((())()))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()()()()))((()()())((())()()()))((()()())((())()()()()()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()()()))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()()()()()))((()()()())((())()()()()()()()()))((()()())((())))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()()()()()()()()()))((()()())((())()()()))((()()())((())))((()()()())((())()()))((()()()())((())))((()()())((())()()))((()()())((())()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()))((()()()())((())()()()()()()()()))((()()())((())()()()))((()()())((())()()()()()()()))((()()()())((())()()()()()()()()))((()()())((())()()()()()()())))

( Référentiel Github pour Parenthetic )

J'ai une réponse CJam pour cela qui est plus courte que la chaîne elle-même, mais je ne peux pas l'utiliser, alors j'ai pensé que j'irais dans l'autre sens.

Code générateur Python 3:

char97 = "((()()())(()()()())((()())((()(())()))((()(())(())())((()(()))(()(())())((()(()))((())())((()()(()))((())()()()()()()()())((())()()()()()()()()()()()())))))))"
char108 = "((()()())(()()())((()())((()(())()))((()()()())((()(()))(()(())())((())()()()()()()()()()()())))))"
open_str = "((()(()))"
close_str = ")"

target = "pneumonoultramicroscopicsilicovolcanoconiosis"
output = [char97, char108, open_str]

for c in target:
    if ord(c) >= 108:
        output.append("((()()())((())%s))"%("()"*(ord(c)-108)))
    else:
        output.append("((()()()())((())%s))"%("()"*(ord(c)-97)))

output.append(close_str)
print("".join(output))

Voici le code de type Lisp correspondant:

(define f (lambda (n) (char (+ n 97))))
(define g (lambda (n) (f (+ n 11))))

(+
   (g 4)  // p
   (g 2)  // n
   (f 4)  // e
   ...
)

Apparemment, il était normal de remplacer definepar gas ()(), ce qui économisait beaucoup d'octets.

Tâche 6, CJam, 26 octets

XY]et1>>"Happy New Year!"*

Vérifie que la [month day]partie du tableau d'heure locale est inférieure à [1, 2].

Tâche 7, Python, 73 octets

from random import*
print(*map(chr,sample(range(13312,19894),64)),sep="")

Juste une implémentation simple de Python 3.

Tâche 8, Prélude, 46 41 octets

?(?)#(#)?(v-(#)?)10)!
      ^      1 # (0

( Page wiki Esolang pour Prelude )

Je pense que cela fonctionne - c'est probablement encore golfable, mais c'est la première fois que je fais un golf non trivial dans Prelude. Le format d'entrée est <needle>NUL<haystack>, où NULest 0x00. Cela fonctionne mieux avec NUMERIC_OUTPUT = Truel'interpréteur Python, car cela le rendra en sortie 1ou 0approprié.

J'ai choisi Prelude parce qu'il y a deux propriétés qui le rendent très agréable pour cette tâche:

• Il est basé sur une pile, vous pouvez donc commencer par lire dans l'aiguille, puis traiter la botte de foin un caractère à la fois, puis
• La pile de Prelude a un nombre infini de 0 en bas, vous n'avez donc pas besoin de gérer le cas où l'aiguille manque de caractères.

Cela aurait été encore mieux si Prelude avait un opérateur NOT.

Voici la ventilation:

?(?)#    Read input up to the NUL, discarding the NUL afterwards

(#)      Move the needle to the second voice, effectively reversing the stack
 ^

?(...?)  Read haystack

  v-     Compare top needle char with haystack char by subtraction

  (#)    If equal, pop the needle char
   1 #

10)!     Output 1 if the top needle char is 0 (bottom of stack), 0 otherwise
(0

(-5 octets grâce à @ MartinBüttner)

Tâche 9, Mathematica, 4 octets

#2#&

Quelque chose ressemble à 2 {{0, 1}, {1, 0}}la multiplication implicite dans Mathematica, cela met donc les arguments côte à côte.

Comme le notent @MartinButtner et @alephalpha , il 1##&existe une autre réponse sur 4 octets. Voir le premier pour une explication.

Tâche 10, Rail, 246 237 octets

$'main'
 0/aima19-@
@------e<
         -(!!)()[ ][ ______ ]{f}[\n\]o()[ ][|      |]{f}[\n\]o()[~][ ()--() ]{f}#
$'f'                 #           #
 -(!x!)(!y!)(!!)()0g<  -(x)o()1g<  -(y)o()1s(y)(x){f}#
                     -/          -/

( Page wiki Esolang pour Rail )

Je ne pouvais pas laisser passer l'occasion de faire une tâche liée au train dans Rail :) Les espaces semblent assez golfables, mais avec les branches prenant trois lignes, il faudra un peu de travail pour se compacter.

L'entrée est un entier via STDIN, mais il doit y avoir un EOF. La partie en haut à gauche

 0/aima19-@
@------e<

est une boucle atoi qui convertit l’entrée en un entier non EOF (vérifié par l’ einstruction).

La fonction fsur les trois dernières lignes prend x, y, net sort les x ntemps de chaîne , séparés par y. La fonction est récursive, avec une ndécrémentation de un à chaque fois jusqu'à devenir zéro. fest appelé trois fois, fournissant différentes chaînes pour chaque ligne. Bizarrement, Rail permet aux noms de variables d'être vides, ce qui économise quelques octets.

La plupart des octets viennent malheureusement de (!x!), ce qui fait apparaître le haut de la pile et l’assigne à variable x, et (x)qui pousse xsur la pile. Cela est nécessaire car il n'y a pas d'opérateur en double dans Rail, c'est donc (!x!)(x)(x)le seul moyen de copier le haut de la pile.

Tâche 1, CJam, 7 octets

q~,:+_*

Je voulais juste obtenir la solution CJam optimale (vraisemblablement) pour cela en. Elle tient compte du fait que la somme des n premiers cubes est le carré du nième nombre triangulaire, qui est elle-même la somme des n premiers entiers.

Testez-le ici.

Tâche 4, Fission, 173 88 78 69 68 octets

Dépôt GitHub pour la fission.

 /@\O/S@+>\
^{ }[<X/ @/;
,\?/@\J^X\
'M~\$ $
UK/W%@]  /
D
?\{\/
0'A Y

Mon deuxième programme de fission raisonnablement compliqué. :)

Le format d'entrée est un peu bizarre. Pour prendre en charge les entrées négatives, le premier caractère est censé être soit le +soit -le signe. La valeur d'octet du second caractère est alors la magnitude de l'entrée (puisque Fission ne peut pas lire de manière native des entiers décimaux). Donc, si vous voulez, 111vous pouvez le transmettre +oà STDIN. Et si vous voulez, -56vous le passez -8. À la place de +et -vous pouvez utiliser n’importe quel caractère avec un code de caractère inférieur ou supérieur, respectivement. Cela peut être utile de passer quelque chose comme -n(que votre echogâterie pourrait comme argument) comme, par exemple, 0n.

Voyons comment trouver la représentation négabinaire d'un nombre positif. Nous voulons calculer le nombre du bit le moins significatif au bit le plus significatif (nous allons placer ces bits sur une pile et les imprimer tous à la fin pour les obtenir dans le bon ordre). Le premier chiffre correspond alors simplement à la parité du nombre, et nous divisons le nombre entier par 2 pour continuer le traitement. Le chiffre suivant est maintenant négatif (avec la valeur -2) - mais il convient de noter que ce bit sera défini chaque fois que le bit 2 sera défini dans un nombre binaire normal. La seule différence est que nous devons contrer le -2 avec des chiffres positifs plus élevés. Nous faisons donc ceci:

• Nous déterminons à nouveau la parité - c'est le prochain négabit - et divisons par 2 comme auparavant.
• Si ce chiffre était un 1, nous incrémentons le nombre restant de 1 afin de neutraliser le bit négatif (la différence entre un négatif et un bit correspond une fois à la valeur du prochain bit le plus significatif).

Une grande simplification des résultats du code de remarquer que l' ajout d' une condition ici équivaut à arrondir le nombre jusqu'à quand entier divisant (si le bit mis au rebut était 1, on incrémente le résultat divisé entier par 1).

Ensuite, le bit suivant est simplement une valeur positive afin que nous puissions le déterminer normalement. Cela signifie que nous voulons une boucle qui calcule deux bits à la fois, en alternant les valeurs arrondies vers le haut et le bas, mais nous souhaitons entrer la boucle au milieu de manière à commencer par arrondir.

Comment pouvons-nous gérer des entiers négatifs? Le problème est que Fission ne peut pas vraiment faire de l'arithmétique arbitraire sur les entiers négatifs, car les masses sont toujours non négatives. Il faudrait donc faire quelque chose de vraiment compliqué, comme travailler avec l’ampleur et garder le signe ailleurs. Cependant, la représentation négative d'un nombre négatif peut être calculée en fonction d'un nombre positif associé:

Si n est négatif, calculez la représentation négabinaire de n / 2 (arrondi au- dessus ) et ajoutez la parité de n .

C'est exactement la première étape de notre boucle à deux bits. Il suffit donc de commencer la boucle à un point différent si le signe est négatif.

La plupart des économies réalisées sur les 173 octets d'origine provenaient de ces informations, ce qui m'a permis de compresser trois contrôles de parité et une boucle à deux sections en une seule boucle avec un seul contrôle de parité.

Ce message deviendra trop long si j'explique tout le code en détail, mais je vais indiquer quelques sections pour donner une présentation approximative du flux de contrôle. Vous pouvez alors brouiller les détails avec la référence Fission.

 /@\
^{ }[
,\?/
'
U
D
?

En commençant par le D, cela lit un signe dans l'énergie et la magnitude dans la masse d'un atome qui aboutit dans le [(allant à droite). Ce bit de signe alternera après chaque passage du contrôle de parité et déterminera si nous conservons la moitié arrondie vers le haut ou la moitié supérieure de l’entrée de la boucle.

     /S@+>\
    [<X/ @/
 \  @\J^X\
 M  $ $
 K  %@]  /

C'est la boucle qui calcule les bits individuels et alimente la moitié correcte dans la prochaine itération. Le Set le Jsont utilisés pour créer une copie de la moitié droite en fonction du bit de signe actuel, le Xs effectue la copie. Le >coin en haut à droite calcule le bit réel qui est ensuite envoyé à la pile Kpour être récupéré plus tard. Je pense que la disposition du coin en haut à droite est très chouette et qu'il vaut vraiment la peine d'étudier en détail si vous êtes intéressé par Fission.

Le %est un commutateur qui renvoie le nombre dans la boucle tant qu'il est supérieur à 0.

    O


 M~\
 K/W%

 \{\/
0'A Y

Une fois que le nombre atteint 0, il est reflété à la place. Cela démarre une autre boucle qui extrait les bits de la pile, les ajoute au code de caractère de 0et les imprime avec O. Le programme se termine une fois que la pile est vide, car l'atome de contrôle finira par être poussé sur la pile (et ensuite, il ne restera plus d'atomes en mouvement).

Tâche 5, Prélude, 219 179 96 octets

Page Esolangs pour Prélude.

Stack Snippet interpreter pour Prelude.

29+129+716705-7607-05-4759+705-14129+05-18705-29+719+05-1507-19+39+449+767549+03-68(67+^+^+^++!)

Cela a commencé comme un programme Prelude standard à sortie fixe, fabriqué à la main, avec trois voix. Après quelques discussions avec Sp3000, j'ai décidé d'essayer une seule voix. Il s'est avéré que cela fonctionnait très bien, car il est beaucoup plus facile de réutiliser des lettres plus anciennes. Ensuite, Dennis m'a donné quelques indices et j'ai trouvé la version actuelle: l'idée est de placer tous les décalages de la lettre hsur la pile d'une seule voix dans l'ordre inverse, puis de les imprimer un par un en boucle. hest choisi parce qu'il n'y a pas hde chaîne (ce qui est important - sinon le 0décalage mettrait fin à la boucle) et parce qu'il minimise le codage des décalages en termes de décalages à deux chiffres et négatifs.

L'encodage offset a été généré avec ce script CJam .

Tâche 8, Mathematica, 28 octets

LongestCommonSequence@##==#&

Yay pour les built-ins. (La dénomination de Mathematica est un peu bizarre ici ... LongestCommonSubsequencetrouve le plus commun sous - chaîne en LongestCommonSequencetrouve le plus commun sous- séquence .)

Tâche 9, J, 1 octet

*

Identique à l’APL et à K, mais il semble que personne n’a encore pris J.

Tâche 10, rétine, 67 à 60 octets

Dépôt GitHub pour Retina.

(.*).
 ______  $1<LF>|      | $1<LF> ()--() ~$1
+`(.{9})1
$1$1
~$
<empty>

Chaque ligne est placée dans un fichier séparé et <LF>doit être remplacée par un caractère de nouvelle ligne et <empty>doit être un fichier vide. Vous pouvez également mettre tout cela dans un seul fichier et utiliser l' -soption, mais cela ne permet pas d'incorporer des caractères de nouvelle ligne à la place de <LF>. Vous pouvez imiter cela en faisant quelque chose comme

echo -n "111" | ./Retina -s train.ret | ./Retina -e "<LF>" -e "\n"

Comme le montre l'exemple ci-dessus, l'entrée devrait être unaire. L'idée du code est de créer trois copies de l'entrée unaire (moins 1), chacune avec une copie de la ligne correspondante. Ensuite, nous répétons les neuf derniers caractères devant un 1jusqu'à ce que tous les 1s disparaissent, répétant ainsi les lignes si nécessaire. Enfin, nous supprimons la traînée étrangère ~.

Eh, je vais commencer avec un couple, je suppose. Première fois golf.

Tâche 1, Python, 38 21 octets

lambda n:(n*n-n)**2/4

Somme une liste de tous les cubes jusqu'à x. Expression modifiée grâce à xnor

Tâche 2, TI-Basic 89, 244 octets

Func
If iPart(log(x+1)/log(2))=log(x+1)/log(2) Then
 Return log(x+1)/log(2)
Else
 Return 0
EndIf
EndFunc
Func
If isPrime(x)=false
 Return 0
If ipart(log(x+1)/log(2))=log(log(x+1)/log(2)) Then
 Return log(x+1)/log(2)
Else
 Return 0
EndIf
EndFunc

Pas certain à 100% sur celui-ci, testera quand je trouverai de nouvelles piles pour ma calculatrice. isPrime est une propriété intégrée, ipart est une partie entière (2.3 -> 2)

Tâche 3, Perl, 45 à 34 octets

@n=sort{$a-$b}@ARGV;print$n[$#n/2]

fichier perl 1 2 3 4 -> 2. Sauvegardé quelques octets grâce à @nutki. Imprimé plutôt que d'enregistrer en variable, puis en imprimant variable.

Tâche 4, Ruby, 43 à 40 octets

x=2863311530
p ((gets.to_i+x)^x).to_s(2)

Au moins, ça marche en 1.9, je ne sais pas pour 1.8. En binaire, '10' * 16 (ou 2863311530) plus un nombre, xor avec celui 10101010 ... est le negbinary. Affiche une représentation sous forme de chaîne avec des guillemets (3 -> "111" plutôt que 3 -> 111). Impossible de trouver des maths pour écrire x en moins de caractères.

Tâche 5, Malbolge, 682 354 octets

D'``_]>n<|49ixTfR@sbq<(^J\ljY!DVf#/yb`vu)(xwpunsrk1Rngfkd*hgfe^]#a`BA]\[TxRQVOTSLpJOHlL.DhHA@d>C<`#?>7<54X8165.R2r0/(L,%k)"F&}${zy?`_uts9Zvo5slkji/glkdcb(fed]b[!B^WVUyYXQ9UNrLKPIHl/.JCBGFE>bBA@"!7[;{z276/.R2r0)(-&J$j('~D${"y?w_utyxq7Xtmlkji/gf,MLbgf_dc\"`BA]\UyYXWP8NMLpPIHGLEiIHGF(>C<A@9]7<;:3W7w5.-210/(L,%k#('~}C{"y?`_uts9wpXn4rkpoh.lNMiha'eGF\[`_^W{h

Testez en ligne ici Pensez que ceci est aussi court que possible. J'ai joué au golf autant que j'ai pu. Sauvegardé 300 octets, alors quand?

Tâche 6, bash, 62 50 40 octets

[ `date +%j`=1 ]&&echo 'Happy New Year!'

Découvert à propos de% j à partir d'un autre post.

Tâche 10, Befunge-98, 121 octets

>&:>1-:" ____"v
   |,k8: '"__"<
   >a,$:>1-v
      > |
>' 8k,^ #
^|':k4 '|':<
v ',*25$<
>,:1-: ")(--)("v
^," ~"_@#,k6" "<

Changé pour befunge-98. Old était Befunge-93, 227 157 147 octets. Fungi utilisé , écrit en Haskell pour les tests. Utilisé le "faire plusieurs fois k" et en ajoutant des caractères uniques à la pile avec '. J'ai l'impression qu'il est possible de jouer au golf jusqu'à 110 ou moins, mais j'ai déjà passé beaucoup trop de temps là-dessus ...

Première chose: la tâche 6 ne compte techniquement PAS ; J'ai téléchargé unc il y a moins d'une heure. Cependant, je l'ai presque téléchargé ce matin, mais j'ai d'abord décidé d'écrire une suite de tests. Idiot.

En tout cas, voilà!

Notez que la plupart des choses unc sont intentionnellement en arrière, c'est-à- &&dire vraiment , etc. ||, raison pour laquelle certaines opérations semblent bizarres (par exemple, utiliser -pour calculer le cube).

Tâche 1, Haskell, 21 octets

f n=sum$map(^3)[0..n]

Tâche 2, Hy, 135 octets

(import math)(fn[n](and(if(and(not(% n 2))(> n 2))false(all(genexpr(% n i)[i(->> n(math.sqrt)int inc(range 3))])))(->> n dec(& n)not)))

Tâche 3, Dart, 37 octets

Ma première fonction Dart!

f(l){l.sort();return l[l.length~/2];}

Tâche 5, INTERCAL, 1047 octets

DO ,1 <- #46
DO ,1SUB#1 <- #242
DO ,1SUB#2 <- #152
DO ,1SUB#3 <- #208
PLEASE DO ,1SUB#4 <- #248
DO ,1SUB#5 <- #248
DO ,1SUB#6 <- #192
PLEASE DO ,1SUB#7 <- #128
DO ,1SUB#8 <- #128
DO ,1SUB#9 <- #72
PLEASE DO ,1SUB#10 <- #120
DO ,1SUB#11 <- #8
DO ,1SUB#12 <- #224
PLEASE DO ,1SUB#13 <- #200
DO ,1SUB#14 <- #208
DO ,1SUB#15 <- #32
PLEASE DO ,1SUB#16 <- #208
DO ,1SUB#17 <- #120
DO ,1SUB#18 <- #88
PLEASE DO ,1SUB#19 <- #40
DO ,1SUB#20 <- #8
DO ,1SUB#21 <- #208
PLEASE DO ,1SUB#22 <- #232
DO ,1SUB#23 <- #120
DO ,1SUB#24 <- #208
PLEASE DO ,1SUB#25 <- #248
DO ,1SUB#26 <- #56
DO ,1SUB#27 <- #96
PLEASE DO ,1SUB#28 <- #160
DO ,1SUB#29 <- #208
DO ,1SUB#30 <- #208
PLEASE DO ,1SUB#31 <- #136
DO ,1SUB#32 <- #120
DO ,1SUB#33 <- #192
PLEASE DO ,1SUB#34 <- #112
DO ,1SUB#35 <- #64
DO ,1SUB#36 <- #16
PLEASE DO ,1SUB#37 <- #128
DO ,1SUB#38 <- #48
DO ,1SUB#39 <- #208
PLEASE DO ,1SUB#40 <- #128
DO ,1SUB#41 <- #224
DO ,1SUB#42 <- #160
PLEASE DO ,1SUB#43 <- #40
DO ,1SUB#44 <- #56
DO ,1SUB#45 <- #200
PLEASE DO ,1SUB#46 <- #126
PLEASE DO READ OUT ,1
DO GIVE UP

Tâche 6, unc, 157 octets

!include>=fgQVb%U<=
!include>=gVZR%U<=
false lRNe[]<<gVZR_g t:=gVZR[5]:volatile gZ m:=-YbPNYgVZR[&t]:for[#m%gZ_Zba||m%gZ_ZQNl!=6]chgf[L'uNccl ARj LRNe#']:>>

Tâche 8, rs, 42 octets

#
+#(.)(.*) .*?\1/\1#\2 
.*# .*$/1
[^1]+/0

Démo en direct.

Tâche 10, Pyth, 46 octets

jb(j*d2m+\ *\_6Qjdm"|      |"Qj\~m" ()--() "Q)

Démo en direct.

Tâche 1, APL, 7 octets

+/3*⍨⍳⎕

Vous pouvez l’ essayer en ligne avec ngn / apl, bien que cela fonctionne avec toutes les implémentations APL dont la valeur par défaut est 0.

Cela met chaque entier de 0 à l'entrée ( ⍳⎕) -1 en commutant ( ⍨) les arguments de l'opérateur en charge ( *). Le vecteur résultant est réduit par sommation ( +/) et un scalaire est renvoyé.

Tâche 2, Julia, 42 octets

n->(isprime(n)&&int(log2(n+1))==log2(n+1))

Cela crée une fonction anonyme qui accepte en tant qu'entier en entrée et retourne un booléen. Pour l'appeler, donnez-lui un nom, par exemple f=n->....

En premier lieu, nous utilisons la fonction intégrée de Julia isprimepour vérifier si elle nest primordiale. Si c'est le cas, nous vérifions qu'il log2(n+1)s'agit d'un entier. Si c'est le cas, npeut être écrit comme 2^k-1pour certains k, et nest donc un prime de Mersenne.

Tâche 3, ELI , 19 octets

{f:x[<x][~.0.5*#x]}

Cela crée une monade fqui renvoie la médiane du vecteur d’entrée.

Ungolfed + explication:

{f:         // Define a function f
 x[<x]      // Sort the input vector
 [          // Select the element at index...
 ~.0.5*#x   // ceiling of 0.5 * length(input)
]}

Exemples:

    f 1 2 3 4
2
    f ?.!20   // Apply f to 20 random integers in 1..20
4

Tâche 4, octave, 39 octets

@(n,x=2863311530)dec2bin(bitxor(n+x,x))

Cela crée un descripteur de fonction qui accepte un entier en entrée et retourne la chaîne négabinaire associée. Pour l'appeler, nommez-le, par exemple f=@..., et lancez avec feval(f, <input>).

Vous pouvez l' essayer en ligne .

Tâche 5, CJam, 47 octets

"pneumonoultramicroscopicsilicovolcanoconiosis"

La chaîne est simplement imprimée sur STDOUT. Vous pouvez l' essayer en ligne si vous vous sentez si enclin.

Tâche 6, batch Windows, 46 octets

if "%date:~4,5%"=="01/01" echo Happy New Year!

La variable %date%contient la date du jour dans le formulaire Thu 06/25/2015. Nous pouvons sélectionner le mois et le jour en obtenant la sous - chaîne de longueur 5 après avoir sauté les 4 premiers caractères: %date:~4,5%. À partir de là, nous vérifions si c'est le 1er janvier et disons bonne année si c'est le cas.

Tâche 7, Pyth, 26 octets

=Gr13312 19895FNU64pC.(.SG

Nous Gattribuons d’ abord la plage 13312 à 19894 inclus. Ensuite, nous bouclons 64 fois, et à chaque itération, nous shuffle G( .SG), retirons et renvoyons le dernier élément ( .(), et imprimons sa représentation de caractère ( pC).

Vous pouvez l' essayer en ligne .

Tâche 8, Ruby, 36 octets

def f(a,b)!b.tr("^"+a,"")[a].nil?end

Ceci définit une fonction fqui accepte deux chaînes aet b, où aest la chaîne à rechercher b.

Tout, à l'exception des caractères, aest supprimé de l' butilisation .tr()et nous vérifions si le résultat contient aexactement utiliser []. Cela retournera nilsi la chaîne n'est pas trouvée, ainsi nous pouvons obtenir une valeur booléenne en utilisant !avec .nil?.

Tâche 9, R, 16 octets

function(x,n)n*x

Cela crée un objet fonction non nommé qui accepte tout type de tableau ou de matrice xet un entier net multiplie chaque élément xpar n. Si vous le souhaitez, vous pouvez l' essayer en ligne .

Tâche 10, Python 3, 92 octets

n=int(input())
l="\n"
w=" ()--() "
print(" ______  "*n+l+"|      | "*n+l+(w+"~")*(n-1)+w)

Assez simple. Vous pouvez l' essayer en ligne .

Tâche 1,> <>, 10 + 3 = 13 octets

::*-:*4,n;

Exécutez cette opération en utilisant l’ interpréteur Python officiel en utilisant le -vdrapeau (pour un coût de 3 octets). Cela équivaut à diviser par la quantité (n - n*n)et à diviser par 4ce qui équivaut bien sûr à quadriller (n*n - n)et diviser par 4.

Tâche 2, GAP, 63 62 octets

b:=function(m)return[2]=AsSet(Factors(m+1))and IsPrime(m);end;

(Vous avez sauvegardé un espace en écrivant l'égalité à l'envers.)

Tâche 3, R, 43 39 octets

f=function(v)sort(v,d=T)[length(v)%/%2]

Merci à Plannapus pour cette belle amélioration!

Tâche 4, Piet, 155 135 115 5 * 19 = 95 codels

Testez à l'aide de cet interprète en ligne , de taille 13 ou utilisez votre interprète préféré - faites-moi savoir si vous en avez un que vous aimez!

Le rendre en sortie 0au lieu de la chaîne vide pour l'entrée 0était peu pratique. J'ai utilisé un si-alors près du début pour prendre soin de cette affaire; puis une boucle while pour calculer les chiffres dans le cas non nul, et enfin une autre boucle while à la fin pour sortir les chiffres de la pile.

Merci beaucoup à Sp3000 pour ces commentaires très utiles qui m'ont aidé à économiser des codes!

Tâche 5, Lua, 52 octets

print"pneumonoultramicroscopicsilicovolcanoconiosis"

Vous pouvez l'essayer ici .

Tâche 6, LaTeX, 157 139 136 127 128 octets

\documentclass{book}\begin{document}\count1=\day\multiply\count1 by\month
\ifcase\count1\or Happy New Year!\else~\fi\end{document}

Si le produit du jour et du mois est 1, imprimez le message; sinon rien. (Le jour du Nouvel An est particulièrement pratique pour cette conception: comme le résultat recherché est 1, nous n'avons besoin que d'une orinstruction. L' énoncé nth orspécifie le comportement de la valeur n.)

Remarque: la version précédente manquait dans ma version précédente, ce qui était une erreur. (J'ai essayé de tester cette fonction, mais le tester correctement pourrait prendre un peu de temps ...)

Ma version originale utilisait le calcpackage, ce qui était beaucoup plus pratique que ma version actuelle. Quelque chose à garder à l'esprit pour la "vraie vie"!

Tâche 7, Ruby, 62 octets

for r in Array(13312..19893).sample(64)
puts [r].pack('U*')end

Tâche 8, JavaScript, 78 octets

h=function(l,m){u=1+m.indexOf(l[0]);return(!l||u&&h(l.substr(1),m.substr(u)))}

Solution récursive, testant si lest une sous-chaîne de m. Si lest vide, alors les !lrésultats trueet la fonction se terminent. (Dans ce cas, l[0]non défini, mais JavaScript convient à cela.) Sinon, il recherche la première instance de l[0]in m. Si elle ne trouve pas un, puis m.indexOf(l[0])entraîne -1et ainsi les urésultats en 0et les fonctions se termine.

Sinon, il supprime la première entrée let les premières uentrées met continue de vérifier.

Tâche 9, Python, 72 à 60 octets

def i(a,n):
 try:return[i(c,n)for c in a]
 except:return n*a

Détaille au "niveau le plus bas", où an'est plus une liste, mais un entier, puis effectue la multiplication.

Merci à Dennis de m'avoir sauvé 12 octets!

Tâche 10, Groovy, 81 octets

def j(n){(' ------  '*n+'\n'+'|      | '*n+'\n'+' ()--() ~'*n).substring(0,27*n)}

Essayez ici . A l'origine, j'avais essayé d'implémenter quelque chose comme la .join()méthode de Python pour les chaînes, qui associe des chaînes avec une "chaîne de liaison" particulière (comme les liens entre les wagons de train). Mais cela a coûté beaucoup plus que ce qu’il a économisé.

J'espère que je n'ai pas manqué à toutes les conventions pour des réponses acceptables dans ces différentes langues, mais s'il vous plaît, laissez-moi savoir si c'est le cas.

Merci à Dennis pour ce défi fantastique!

Tâche 1, Pyth, 5 octets

s^R3Q

Prend le numéro de stdin. Merci @Jakube pour nous avoir signalé l'inutile U.

Tâche 6, javascript, 56 octets

if(Date().slice(4,10)=="Jan 01")alert("Happy New Year!")

Tâche 7, CJam, 16 octets

6581,mr64<'㐀f+

Génère une plage, mélange, choisit en premier 64 et mappe l’addition de la valeur de départ et la conversion en caractère. 14 caractères, 16 octets.

Tâche 8, octave, 23 octets

@(x,y)intersect(x,y)==x

Définit la fonction anonyme.

Tâche 5, PHP, 45 octets

pneumonoultramicroscopicsilicovolcanoconiosis

Pas de compression, juste des impressions.

Tâche 9, APL 1 octet

 ×

La même chose que la réponse K.

Tâche 1, R, 21 19 octets

sum((1:scan()-1)^3)

Assez simple. Entrée de STDIN.

Tâche 2, Perl, 40 à 66 octets

$a=log(<>+1)/log(2)+1;print$a==int($a)&&(1x$a)!~/^1?$|^(11+?)\1+$/

Ajout d'un vérificateur principal (regex du vérificateur de nombres premiers Abigails)

Tâche 3, PARI / GP, 24 22 octets

m(v)=vecsort(v)[#v\2];

La première fois que j'ai touché ceci. Il faudra peut-être en apprendre un peu plus.

Tâche 4, T-SQL, 235 octets

CREATE FUNCTION D(@ INT)RETURNS TABLE RETURN WITH R AS(SELECT @/-2+(IIF(@%-2<0,1,0))D,CAST(ABS(@%-2) AS VARCHAR(MAX))M UNION ALL SELECT D/-2+(IIF(D%-2<0,1,0)),CAST(ABS(D%-2)AS VARCHAR(MAX))+M FROM R WHERE D<>0)SELECT M FROM R WHERE D=0

Fonction de table en ligne utilisant un CTE récursif. Très grand, mais amusant à faire.

Utiliser

SELECT * FROM D(18)
M
------
10110

Tâche 5, GAP, 48 octets

"pneumonoultramicroscopicsilicovolcanoconiosis";

Tâche 6, Excel, 51 48 octets

=IF(TEXT(NOW(),"md")="11","Happy New Year!","")

Merci à @Bond pour les 3 octets.

Tâche 7, Python 2.6, 98 93 85 octets

from random import*
l=range(13312,19893)
shuffle(l)
print ''.join(map(unichr,l[:64]))

C'est la première fois que j'essaie de faire quelque chose en Python, alors ça pourrait être beaucoup mieux. Merci @Dennis et @Jacob pour les bons conseils

Tâche 8, TCL, 57 octets

proc m {a b} {string match [regsub -all (.) $a *\\1]* $b}

Dommage que la suppression des espaces tue cette

Tâche 9, brochet, 53 octets

mixed m(array(array(int))a,int n){return(a[*])[*]*n;}

Une fonction qui retourne le tableau multiplié

Tâche 10, Powershell, 88 octets

Function t($n){Foreach($s in "  ______ "," |      |","~ ()--() "){($s*$n).Substring(1)}}

Une fonction Powershell. Je pense pouvoir le raccourcir un peu, mais le voici pour le moment.

Et enfin fini :)

Tâche 2, J, 10 octets

1&p:*/@,#:

Prépose un booléen 0 ou 1 à l'avance si l'entrée est primordiale à sa représentation binaire, puis prend le produit. Fonctionne sur la version actuelle de J.

Tâche 5, HTML, 45 octets

pneumonoultramicroscopicsilicovolcanoconiosis

Tâche 6, poisson, 53 octets

test 0101 = (date '+%d%m');and echo 'Happy New Year!'

Basé sur la réponse bash.

Tâche 8, APL, 12 octets

{(⍳⍴⍺)≡⍋⍵⍳⍺}

Ceci est une expression de fonction. Il compare l'ordre des caractères trouvés dans la plus grande chaîne avec ce à quoi on pourrait s'attendre s'ils étaient triés.

Tâche 9, K, 1 octet

*

Devrait fonctionner dans n'importe quelle version. Les opérations arithmétiques distribuent sur des tableaux.

Tâche 1, Ruby, 40 octets

def f n;(0..n-1).inject{|a,b|a+b**3};end

La première fois que j'écris quelque chose en ruby. Testé avec du rubis 1.8.7.

Tâche 2, R, 50 octets

n=scan();p=log(n+1,2);!p%%1&sum(!n%%2:n,!p%%2:p)<3

Calcule p, vérifie s'il s'agit d'un entier et si n et p sont des nombres premiers.

Tâche 5, PostgreSQL, 54 octets

SELECT'pneumonoultramicroscopicsilicovolcanoconiosis';

Tâche 6, Lua, 55 octets

print(os.date("%j")=="001" and "Happy New Year!" or "")

Tâche 8, Python, 65 octets

import re;f=lambda s,S:bool(re.search(re.sub(r'(.)',r'\1.*',s),S))

Usage:

>>> import re;f=lambda s,S:bool(re.search(re.sub(r'(.)',r'\1.*',s),S))
>>> f('abc','axbxcx')
True
>>> f('bac','axbxcx')
False
>>> f('abc','axdxcx')
False
>>> f('abc','abc')
True

Tâche 10, Julia, 73 octets

f(n)=print(" ______  "^n*"\n"*"|      | "^n*"\n"*(" ()--() ~"^n)[1:9n-1])

Merci à @AlexA. pour avoir aidé à raccourcir ce code! Exemple de sorties:

julia> f(0)




julia> f(1)
 ______  
|      | 
 ()--() 

julia> f(2)
 ______   ______  
|      | |      | 
 ()--() ~ ()--() 

julia> f(3)
 ______   ______   ______  
|      | |      | |      | 
 ()--() ~ ()--() ~ ()--() 

Tâche 1, Haskell, 17 octets

f x=(x*(x-1)/2)^2

Tâche 2, Mathematica, 30 octets

PrimeQ@#&&Mod[Log2[#+1],1]==0&

Tâche 3, JavaScript, 46 octets

function(x){return x.sort()[0|(x.length-1)/2]}

Tâche 5, MATLAB, 47 octets

'pneumonoultramicroscopicsilicovolcanoconiosis'

Tâche 6, Ruby, 56 octets

print Time.now.to_s[5,5]=="01-01"?"Happy New Year!":""

Tâche 7, Python, 106 octets (en retrait avec \t)

from random import*
s=''
while len(s)<64:
    c=unichr(randint(0x3400,0x4DB5))
    if c not in s:
        s+=c
print s

Notez que l’utilisation directe de list(set(s)) ne fonctionne pas ici car cela entraînera une distribution de probabilité non uniforme dans l'espace de toutes les chaînes possibles en raison de la réorganisation des membres de la liste.

Tâche 1, Haskell, 15 octets

f n=(n*n-n)^2/4

Tâche 2, Julia, 28 octets

n->(isprime(n)&&ispow2(n+1))

Tâche 3, octave, 30 octets

@(x)sort(x)(ceil(length(x)/2))

Tâche 5, Yacas , 45 octets

pneumonoultramicroscopicsilicovolcanoconiosis

Tâche 6, Mathematica, 46 octets

If[DateList[][[{2,3}]]=={1,1},Happy New Year!]

Tâche 9, PARI / GP, 10 octets

(n,a)->n*a

Tâche 3, Clip, 13 octets

gHk[tivt}l`sk

Une autre version:

gHkci`v``l`sk

le ` semblait coûter trop cher.

Tâche 4, KSFTgolf, 16 octets

g:]2%:)-2/:;xgpc

L'interprète est ici.Je ne suis pas sûr de ce que je suis en train de faire ... Cela imprimera le négatif puis se plantera.

Il y a un bug dans l'interprète. Ou je pourrai réduire jusqu'à 12 octets en utilisant la conversion de base intégrée (mais cela ne fonctionne qu'avec les entiers positifs):

2*02-ba'Z=;x

Version originale de CJam:

qi{_1&_@^-2/}h;]W%

J'ai essayé Pip, Autruche, Clip et Burlesque pour savoir s'il existe un esolang avec negabinary intégré. Aucun d'entre eux a travaillé. KSFTgolf utilisénumpy , qui semblait avoir un comportement étrange quand la base est négative. Mais ce n'est pas facile de le faire fonctionner avec des nombres non positifs.

Tâche 7, CJam, 15 octets

'䶶,DAm<>mr64<

Tâche 8, APL, 21 octets

∨/↑{⍺∧0,2∧/∨\⍵}/⌽⍞=↓⍞

Essayez-le en ligne.

Tâche 2, x86 masm, 40 octets

C7 45 FC FF FF 07 00 B9 
00 00 00 00 B8 02 00 00 
00 D3 E0 3B 45 FC 7D 03 
41 EB F1 B8 02 00 00 00
D3 E0 48 3B 45 FC 75 13

(à l'exclusion de l'en-tête, de MessageBox, etc. - octets pertinents uniquement)

include     \masm32\include\user32.inc  
includelib  \masm32\lib\user32.lib

.data
    ClassName   db "Mersenne Prime Found",0
.data?

.code
start proc
    LOCAL IsMersenne: DWORD
    mov IsMersenne, 524287 ; put number to test in this input
    mov ecx, 0
l00p:
    mov eax, 2
    shl eax, cl
    cmp eax, IsMersenne
    jge br3ak
    inc ecx
    jmp l00p
br3ak:
    mov eax,2                                                                                     
    shl eax, cl 
    dec eax
    cmp eax, IsMersenne                                                           
    jnz n0pr1me                                                              
    invoke MessageBox, 0, addr ClassName, addr ClassName, 40h
n0pr1me:
    ret
start endp
end start

Tâche 3, C, 136 octets

#include<stdio.h> 
int C(void*A,void*B){return(*(int*)A-*(int*)B);} 
main(){int S=4;int A[]={3,1,2,4};qsort(A,S,4,C);printf("%i",A[((S&1)?S:S-1)/2]);}

Compiler en utilisant gcc -o Prime main.c

Tâche 10, C ++, 478 octets

#include<stdio.h>
#include<string.h> 
#include<stdlib.h>
void D(int Z){int L=9,i,X=0;const char*A=" ______  ";const char*B="|      | ";const char* C = " ()--() ~ ";char*P=(char*)malloc(27*Z+5);for(i=0;i<Z-1;i++){if(!i){memcpy(P,A,L);X+=L;}memcpy(&P[X],A,L);X+=L;if(i==Z-2){memcpy(&P[X],"\n",1);X++;}}for(i=0;i<Z;i++){memcpy(&P[X],B,L);X+=L;if(i==Z-1){memcpy(&P[X],"\n",1);X++;}}for(i=0;i<Z;i++){memcpy(&P[X],C,L);X+=L;if(i==Z-1)P[X-1]='\0';}printf("%s\n",P);free(P);}
main(){D(15);}

Compiler en utilisant g++ -o Trucks main.cpp

C & C ++ peut être raccourci mais cela ajouterait une erreur du compilateur. Ne connaissant pas les règles exactes, j'ai essayé de laisser du code sans erreurs de compilation.

Tâche 1, Python, 35 octets

lambda x:sum(_**3for _ in range(x))

Tâche 3, CJam, 9 octets

q~$_,(2/=

Tâche 4, JavaScript, 55 53 octets

function(n){s=0xAAAAAAAA;return((n+s)^s).toString(2)}

Tâche 5, Pyth, 46 octets

"pneumonoultramicroscopicsilicovolcanoconiosis

Tâche 6, C #, 65 octets

string c(){return DateTime.Now.DayOfYear<2?"Happy New Year!":"";}

Tâche 1, jq, 24 octets

[range(1;.)|.*.*.]|add+0

Tâche 6, PostgreSQL, 54 octets

select'Happy New Year!'where'001'=to_char(now(),'DDD')

Tâche 1, Cjam, 7 octets

q~,:+_*

Edit: Je viens de remarquer que Martin a posté ceci avant moi. Je vais essayer autre chose ...

Tâche 3, Python, 30 octets

lambda l:sorted(l)[~-len(l)/2]

Python 2.

Tâche 5, ///, 45 octets

pneumonoultramicroscopicsilicovolcanoconiosis

/// fera juste écho quelque chose sans aucun /caractère.

Tâche 7, Pyth, 19 octets

s>64.SmC+13312d6582

Programme. S'il te plaît, dis-moi si j'ai tout gâché. Essayez-le ici

Tâche 9, octave, 9 octets

@(a,n)a*n

Poignée de fonction anonyme. Octave le fait automatiquement avec matrix * scalar.

Je n'ai pas trouvé le temps de toutes les essayer, mais voici un début

Tâche 1, courant continu, 8 octets

d1+*d*4/

Entrée et sortie en haut de la pile, selon dc convention.

Tâche 5, Emacs Lisp, 46 octets

'pneumonoultramicroscopicsilicovolcanoconiosis

Abus des règles:

grep 'pn.*v' /usr/*/*/brit*-large

Le mieux que j'ai pu gérer en décompressant à partir d'une forme compressée était de 55, en Perl:

unpack("H45",'uïFVóÙ¤¼g°0Æö<¥le°°')=~y/0-9bdf/i-v/r

(Les caractères non imprimables ci-dessus sont déformés par SE, mais comme ce n'est pas ma réponse, je ne la répare pas)

Tâche 6, SQL, 54 octets

SELECT IF(now()LIKE'%-01-0_%','Happy New Year!','Hi');

Je considère que les dix premiers jours de janvier sont des jours «appropriés» pour cette salutation, mais vous pouvez vous adapter au goût. La now() LIKEconstruction est plus courte que l'extraction du jour de l'année DATE_FORMAT(now(),'%j').

Tâche 10, sed, 58 octets

s/./ ()--() ~/g;s/.$//;h;y/()-~/___ /;p;g;y/ ()-~/|    /;G

Entrée en unaire.

Tâche 5, MarioGolf , 50 octets

C'est un langage que j'ai développé depuis un certain temps.

La version actuelle a suffisamment de fonctionnalités pour permettre de lancer ce défi.

Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O

Vous pouvez l'essayer en ligne sur http://htmlpreview.github.io/?https://raw.githubusercontent.com/ismael-miguel/mariogolf/master/js/testpage.html#c:Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O

Actuellement, le développement est arrêté et la mise en œuvre est incomplète.

Le dernier engagement a eu lieu le 13 mars 2015.

Tâche 6, PHP, 37 octets

Celui-ci est vraiment facile et amusant!

<?=date(jn)==11?'Happy New Year!':'';

Tâche 10, Javascript, 121 byes

Ouais, pas si golfé ...

Mais ça fait le travail!

console.log((' ______  '.repeat(i=prompt()))+'\n'+('|      | '.repeat(i))+'\n'+(' ()--() ~'.repeat(i).replace(/~$/,'')));

Essayez le:

//Required to show the console messages on the document
console._RELAY_TO_DOC = true;

console.log((' ______  '.repeat(i=prompt()))+'\n '+('|      | '.repeat(i))+'\n '+(' ()--() ~'.repeat(i).replace(/~$/,'')));

<script src="http://ismael-miguel.github.io/console-log-to-document/files/console.log.min.js"></script>

Le code ne s'affichera pas bien dans l'extrait de pile car il commence par " dans la sortie. Des espaces supplémentaires ont été ajoutés pour compenser.

Le code d'origine peut être exécuté sur la console de Chrome sans aucun problème et le résultat sera celui attendu.

Tâche 1, CJam, 10 octets

li,{3#}%:+

Essayez ici

Tâche 5, rétine, 46 octets

<empty>
pneumonoultramicroscopicsilicovolcanoconiosis

Tâche 1, octave, 15 octets

@(n)(n^2-n)^2/4

EDIT: Je pensais avoir ajouté ceci, mais il semble que j’ai oublié de sauvegarder: cela utilise le fait que sum(1^3+2^3+3^3+...+n^3) = sum(1+2+3+...+n)^2 = [n*(n+1)/2]^2

Tâche 3, Javascript, 24 octets

x=>x.sort()[x.length>>1]

Ok, commençons par les choses faciles:

Tâche 5, ASP, 45 octets

pneumonoultramicroscopicsilicovolcanoconiosis

Tâche 6, JavaScript, 46 octets

/an 01/.test(Date())&&alert("Happy New Year!")

Tâche 1, VBA, 126 octets

Function f(n As Integer)
    Dim i As Integer
    For i = 0 To n - 1
        f = f + i ^ 3
        Next i
End Function

Je ne sais pas comment jouer au golf dans VBA. Je n'ai pas tapé un seul espace, VBA insère automatiquement des espaces. =f(5)dans une cellule d'Excel affichera 100.

Tâche 2, octave, 32 octets

@(n)isprime(n)&~mod(log2(n+1),1)

Tâche 5, Golfscript, 47 octets

"pneumonoultramicroscopicsilicovolcanoconiosis"

Tâche 9, MATLAB, 9 octets

@(A,n)A*n

Eh bien, c'est un début ...