Compiti

Tutti i concorrenti cercano di risolvere il seguente elenco di 10 attività:

matematica

1. Leggere un numero intero positivo n dall'input e restituire la somma dei cubi dei primi n numeri interi non negativi.

   Per l'input 1, questo dovrebbe tornare 0.

2. Leggi un intero positivo n dall'input e restituisce un valore di verità se e solo se n è un numero primo di Mersenne .

3. Leggi un elenco non vuoto di n numeri interi dall'input e restituisce la loro mediana .

   Se n è pari, utilizzare il minore dei due valori medi.

   Ad esempio, la mediana di [1 4 3 2]è 2.

4. Leggi un numero intero (positivo, negativo o 0) o una rappresentazione in stringa in base 10 o unaria, dall'input e restituisce le sue cifre in negabinary , senza zeri iniziali (ad eccezione dell'ingresso 0).

   L'output può essere formattato in qualsiasi modo conveniente (cifre, matrice, stringa, ecc.).

corda

5. Ritorno pneumonoultramicroscopicsilicovolcanoconiosis.

6. Controlla la data corrente e, Happy New Year!se del caso, ritorna secondo il calendario gregoriano.

7. Seleziona pseudo-casualmente 64 punti di codice assegnati univoci dal blocco Unicode CJK Unified Ideographs Extension-A (U + 3400 - U + 4DB5) e restituisce la stringa dei caratteri corrispondenti.

   Tutte le stringhe possibili dovrebbero avere la stessa probabilità di essere selezionate.

8. Leggi due stringhe di caratteri ASCII stampabili dall'input e restituisci un valore di verità se e solo se il carattere della prima stringa forma una sottosequenza della seconda stringa.

   Ad esempio, abc, axbxcdovrebbe tornare truthy e bac, axbxcdovrebbe restituire falsy.

array-manipolazione

9. Leggi una matrice multidimensionale e rettangolare di numeri interi e un numero intero n dall'input e restituisce la matrice modificata con tutti i numeri interi moltiplicati per n .

ascii-art

10. Leggere un numero intero non negativo n dall'input e restituire una catena di n vagoni ferroviari, come mostrato di seguito.

    Esempio di output per n = 3 :

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

    L'output può essere circondato da qualsiasi quantità di spazio bianco purché sia ​​nell'esempio.

chiarimenti

• 0 non è né positivo né negativo.

• Lo spazio bianco finale è sempre consentito nell'output.

• Diverse parti di input possono essere lette in qualsiasi ordine coerente e conveniente.

Regole

1. Nessuna risposta può risolvere due diversi compiti nello stesso linguaggio di programmazione. ¹

2. Per ogni singola attività, si applicano le regole standard del golf di codice .

   In particolare, è possibile inviare programmi o funzioni con i soliti valori predefiniti di I / O , ma non è possibile sfruttare queste lacune .

   L'attività 5 è essenzialmente una sfida per la complessità del kolmogorov , quindi l'hardcoding dell'output non è solo consentito ma previsto.

3. È necessario pubblicare una sola risposta per utente, contenente al massimo una soluzione per ciascuna attività.

   Si prega di formattare la risposta come nell'esempio seguente:

   ## 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.
   

punteggio

1. Per ogni attività che risolvi, ottieni un punto.

   Ciò significa che non è necessario risolvere tutti i compiti per partecipare.

2. Se la soluzione per l'attività n è la più breve in quel linguaggio di programmazione, si ottiene un punto aggiuntivo.

3. Se la soluzione per l'attività n è la più breve di tutti i linguaggi di programmazione, si ottiene un punto aggiuntivo.

4. I punti bonus verranno assegnati una sola volta per ciascuna combinazione lingua-compito e ciascuna attività, rispettivamente.

   Come al solito, se due soluzioni hanno lo stesso numero di byte, il tempo di pubblicazione è il tie breaker.

   Se qualcuno ti supera in un secondo momento, perdi i punti bonus guadagnati dall'altro risponditore.

5. Puoi inviare golf, aggiungere / rimuovere lingue dalla tua risposta o scambiare le lingue utilizzate per due attività.

   Ogni volta che qualcuno modifica la sua risposta, tutte le risposte vengono salvate.

6. Una volta cambiate le lingue per un'attività, si perde l'anzianità. ²

Vince la risposta con il punteggio più alto. ³

Classifica per attività

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

Classifica combinata (30-07-2015 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

Le attività contrassegnate con Xsono presenti ma non valide.

La classifica combinata è stata costruita a mano. Per favore dimmi se ci sono errori.

^{1 Le} _{lingue contano come diverse se non sono versioni diverse della stessa lingua, quindi c'è solo un JavaScript, un Python e un TI-BASIC, ma C, C ++, Octave e MATLAB sono quattro lingue diverse.}

² _{Se si risolve l'attività n utilizzando la lingua L in x byte, qualcun altro risolve la stessa attività nella stessa lingua con lo stesso conteggio byte, si passa alla lingua M e si ripristina la modifica, l'altro risponditore manterrà il punto bonus.}

³ _{Il numero di punti guadagnati dalle regole di punteggio 1, 2 e 3 (in quell'ordine), il conteggio di byte combinato di tutte le attività risolte (minore è migliore) e, infine, il conteggio dei voti (più alto è migliore) serve da pareggio.}

Attività 1, GolfScript, 8 byte

~,{+}*.*

Stessa idea della risposta CJam di Martin .

Task 2, QBasic, 74 71 byte

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

Testato su QB64 con l'espansione della sintassi disattivata. ¹ La maggior parte del programma verifica se il numero indicato aè primo prendendo amod ogni numero 2 <= i< ae moltiplicando i risultati. Il risultato è r0 se il numero non è primo e diverso da zero. L'ultima riga usa bit ANDper bit con divisione intera per 2 per verificare se la rappresentazione binaria di aè tutta una, cioè aè della forma 2 ⁿ -1. Moltiplicandolo per r0 (falso) se un numero non è un numero primo di Mersenne e un valore diverso da zero (verità) in caso contrario. ?è una scorciatoia per PRINT.

Il più grande numero primo di Mersenne che ho provato, 8191, dà il risultato di 1.#INF- che è ancora vero! (Ho verificato con una IFdichiarazione per essere sicuro.)

¹ _{Questo non cambia la semantica del programma. Se si digita il codice precedente nel QBasic DOS standard, verrà formattato automaticamente con spazi extra, ma verrà eseguito esattamente lo stesso.}

Attività 3, Pyth, 6 byte

ehc2SQ

Legge un elenco in stile Python da stdin. La magia principale qui è l' coperatore hop: dato un int e una lista, divide la lista in n pezzi. Quindi c2SQtaglia a metà l'elenco di input ordinato. Convenientemente, quando la lunghezza è dispari, la prima metà è la più grande, quindi la mediana è sempre l'ultimo elemento della prima metà. Questo è il eND del head dei risultati chop.

Attività 4, CJam, 26 byte

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

Questo potrebbe essere abbreviato, sospetto.

Algoritmo:

• Leggi intero.
• Fai mentre il valore non è 0:
  • Prendi addominali (i% 2). Questa è la cifra successiva (negabit?).
  • Dividi i per -2.
  • Se io fossi nonpositivo, aggiungi abs (i% 2) al risultato. Questo serve a correggere un caso d'angolo: 3 va a -1, ma -3 dovrebbe andare a 2, non a 1.
• Rilascia lo 0 superfluo, raccogli la pila in un array, inverti e stampa.

Il fatto che sia un ciclo do-while si occupa del caso 0.

Task 5, Bash, 50 byte

echo pneumonoultramicroscopicsilicovolcanoconiosis

Non c'è molto da spiegare.

Task 6, Python, 78 byte

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

Richiede Python 2. Gli operatori di disuguaglianza concatenati di Python possono essere ben sfruttati qui.

Attività 7, ActionScript, 82 byte

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

ActionScript è un membro della famiglia ECMAScript. Questo codice richiede ActionScript 2 - molto meglio per il golf del codice perché posso usare funzioni obsolete come al chrposto della versione 3 String.fromCharCode!

L'output è nel riquadro della console:

Task 8, Pip, 9 19 byte

La soluzione regex non ha funzionato, quindi eccone una con le operazioni sulle stringhe.

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

Repository Github per Pip .

Prende le due stringhe come argomenti della riga di comando. Quando aè una sottosequenza, genera un numero intero positivo (verità); in caso contrario, il risultato è zero (falsy), che non produce output.

Spiegazione:

                     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

Task 9, Prolog (SWI), 68 byte

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 non è di solito competitivo nel code golf, quindi sono abbastanza contento di questa soluzione.

Definisce un predicato m con i parametri di input Lper l'elenco e Nper il numero e il parametro di output R. La definizione di mè una tripla disgiunzione:

• Se Lpuò essere unificato con [H|T], è un elenco con almeno un elemento al suo interno. Chiama in mmodo ricorsivo in testa e in coda a quell'elenco e riunisci nuovamente i risultati in un nuovo elenco che è unificato R.
• Se Lpuò essere unificato con [], anche unificare Rcon [].
• Altrimenti, Lsi presume che sia un numero; L*Nviene calcolato e assegnato a R.

Esempio eseguito usando swiplsu Ubuntu:

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]]] .

Attività 10, C, 114 112 106 byte

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

Testato con gccsu Ubuntu. Definisce una funzione tche accetta un argomento intero. Utilizza tre forloop per l'output, fortemente condensato attraverso l'abuso di macro. L'uso del carattere backspace per cancellare un trailing si ~traduce in uno schema di spazi bianchi piuttosto strano, maThe output may be surrounded by any amount of whitespace as long as it looks like in the example.

Esempio di esecuzione di t(3):

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

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

Huzzah, prima di completare tutti i compiti! \ O /

Attività 1, Perl, 32 byte

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

+1 byte per la -pbandiera. Commento: Perl è strano .

Attività 2, CJam, 14 byte

{_mp\)2mL_i=&}

Il mio primo programma CJam!

Attività 3, GolfScript, 8 byte

~$.,(2/=

Valuta l'input STDIN, ordina, prendi lunghezza, decrementa, dividi per due, quindi prendi l'oggetto dell'array ordinato in quell'indice.

Task 4, Python, 77 byte

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

Grazie a @ mbomb007 per la rasatura di 24 (!) Byte e a @ Sp3000 per altri 11.

Attività 5, Java, 66 byte

String f(){return"pneumonoultramicroscopicsilicovolcanoconiosis";}

Noioso. Ho messo fuori una lingua verbosa qui per risparmiare spazio per le lingue più golfiste in seguito.

Task 6, Bash, 39 byte

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

Grazie a @manatwork per avermi insegnato %j, radendo 10 byte nel processo.

Attività 7, JavaScript, 148 byte

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})

Generare una stringa di 64 x, quindi sostituirli tutti con una funzione di callback che restituisce uno casuale di quei caratteri se non è già nella matrice di caratteri usati.

Task 8, Rust, 130 byte

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}

Sì, Rust fa molto male al golf.

Task 9, Struzzo, 18 byte

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

Versione 0.7.0 . Ispeziona l'array, sostituisce una regex per modificare i numeri nelle loro versioni moltiplicate e quindi elimina nuovamente la stringa risultante.

Task 10, Ruby, 58 byte

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

"\n"è un personaggio più lungo di "{actual newline}", che è un personaggio più lungo di $/. Grazie a @ MartinBüttner per aver rasato {indeterminato ma un gran numero} byte con vari trucchi di magia nera.

Attività 1, 3var, 14 13 byte

'><k*>#aa/>sp

( Pagina wiki Esolang per 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

Accetta input tramite un punto di codice, ad es. Lo spazio è 32.

Per fortuna tutte le operazioni di cui abbiamo bisogno per implementare la formula n^2 (n-1)^2 / 4sono singoli caratteri (decremento, moltiplicazione e quadratura), ma ci vogliono 3 byte per impostare Ba 2 (reset-incremento-incremento).

Task 2, Retina, 38 33 byte

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

( Repository Github per Retina )

Ogni riga va in un file separato, ma puoi testare quanto sopra come è con il -sflag (sostituendo <empty>con niente). L'input deve essere unario con 1s, ad es. 1111111Per 7.

Ecco cosa fa ogni sostituzione regex (specificata da una coppia di righe):

1. Attacca un ulteriore 1 in avanti
2. Sostituire nulla della forma 2, 1 + compositeo not power of 2con niente.

Questo aggiunge un extra 1ai numeri primi di Mersenne, mentre ogni altro numero viene cancellato.

Attività 3, racchetta, 71 byte

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

Le lingue simili a quelle di Lisp sono semplicemente troppo prolisse. Esempio di esecuzione:

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

Attività 4,> <>, 31 byte

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

( Pagina wiki Esolang per> <> )

Quanto sopra è di 28 byte e richiede il -vflag nell'interprete Python per altri 3 byte , ad es. Come like

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

La cosa bella di> <> qui è che possiamo calcolare le cifre una per una tramite modulo e divisione, che fornisce le cifre in ordine inverso, perfette per stampare da una pila.

Attività 5, parentesi, 1448 1386 byte

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

( Repository Github per Parenthetic )

Ho una risposta CJam per questo che è più corta della stringa stessa, ma non posso usarla quindi ho pensato di andare dall'altra parte.

Codice di generazione di 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))

Ecco il corrispondente codice simile a Lisp:

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

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

Apparentemente era corretto sovrascrivere definenominando gcome ()(), il che ha risparmiato molti byte.

Task 6, CJam, 26 byte

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

Verifica che la [month day]parte dell'array di ora locale sia inferiore a [1, 2].

Task 7, Python, 73 byte

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

Solo un'implementazione semplice di Python 3.

Task 8, Preludio, 46 41 byte

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

( Pagina wiki Esolang per Prelude )

Penso che funzioni: probabilmente è ancora giocabile a golf, ma è la prima volta che faccio un golf non banale a Prelude. Il formato di input è <needle>NUL<haystack>, dove si NULtrova 0x00. Funziona meglio con NUMERIC_OUTPUT = Truel'interprete Python, dal momento che lo farà uscire 1o 0come appropriato.

Ho scelto Prelude perché ci sono due proprietà che lo rendono molto bello per questo compito:

• È basato su stack, quindi puoi prima leggere nell'ago, quindi elaborare il pagliaio un carattere alla volta e
• Lo stack di Prelude ha un numero infinito di 0 in fondo, quindi non è necessario gestire il caso in cui l'ago si esaurisce con i caratteri.

Sarebbe stato ancora meglio se Prelude avesse un operatore NOT.

Ecco la ripartizione:

?(?)#    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 byte grazie a @ MartinBüttner)

Task 9, Mathematica, 4 byte

#2#&

Qualcosa di simile 2 {{0, 1}, {1, 0}}è implicitamente la moltiplicazione in Mathematica, quindi questo mette gli argomenti fianco a fianco.

Come notato da @MartinButtner e @alephalpha , 1##&c'è un'altra risposta a 4 byte. Vedi il primo per una spiegazione.

Task 10, Rail, 246 237 byte

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

( Pagina wiki Esolang per Rail )

Non potevo lasciarmi sfuggire l'opportunità di svolgere un compito relativo al treno in Rail :) Lo spazio bianco sembra piuttosto golfabile, ma con la ramificazione che occupa tre linee ci vorrà un po 'di lavoro per compattare.

L'input è un numero intero tramite STDIN, ma è necessario un EOF. La parte in alto a sinistra

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

è un ciclo atoi che converte l'input in un numero intero mentre non è EOF (verificato edall'istruzione).

La funzione fsulle ultime tre righe prende x, y, ned emette i x ntempi delle stringhe , separati da y. La funzione è ricorsiva, con un ndecremento di uno ogni volta fino a quando non diventa zero. fviene chiamato tre volte, fornendo stringhe diverse per ogni riga. Stranamente, Rail consente di svuotare i nomi delle variabili, risparmiando pochi byte.

Sfortunatamente la maggior parte dei byte proviene (!x!), che apre la parte superiore dello stack e lo assegna alla variabile xe (x), che spinge xsullo stack. Ciò è necessario perché non esiste un operatore duplicato in Rail, quindi (!x!)(x)(x)è l'unico modo per copiare la parte superiore dello stack.

Attività 1, CJam, 7 byte

q~,:+_*

Volevo solo ottenere la (presumibilmente) soluzione CJam ottimale per questo. Fa uso del fatto che la somma dei primi n cubi è il quadrato dell'ennesimo numero triangolare, che è esso stesso la somma dei primi n numeri interi.

Provalo qui.

Attività 4, Fissione, 173 88 78 69 68 byte

Repository GitHub per Fission.

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

Il mio secondo programma Fission ragionevolmente complicato. :)

Il formato di input è un po 'strano. Per supportare input negativi, il primo carattere dovrebbe essere +o -per indicare il segno. Il valore in byte del secondo carattere è quindi l'entità dell'input (poiché Fission non può leggere in modo nativo numeri interi decimali). Quindi, se vuoi 111, lo +opasseresti su STDIN. E se vuoi, -56lo passi -8. Al posto di +e -puoi usare qualsiasi carattere con un codice di caratteri inferiore o superiore, rispettivamente. Questo può essere utile per passare a qualcosa del tipo -n(che echopotresti considerare un argomento) come, ad esempio 0n.

Diamo un'occhiata a come possiamo trovare la rappresentazione negabinaria di un numero positivo. Vogliamo calcolare il numero dal minimo al bit più significativo (inseriremo quei bit in una pila e li stamperemo tutti alla fine per farli nel giusto ordine). La prima cifra è quindi solo la parità del numero e dividiamo il numero per 2 per continuare l'elaborazione. La cifra successiva ora è negativa (con valore -2), ma va notato che questo bit verrà impostato ogni volta che il 2 bit verrebbe impostato in un normale numero binario. L'unica differenza è che dobbiamo contrastare -2 con cifre positive più alte. Quindi quello che facciamo è questo:

• Determiniamo di nuovo la parità - questo è il prossimo negabit - e dividiamo per 2 come prima.
• Se quella cifra era a 1, aumentiamo il numero rimanente di 1 per contrastare il bit negativo (la differenza tra un negabit e un bit è una volta il valore del successivo bit più significativo).

Una grande semplificazione dei risultati di codice da accorgersi che condizionalmente aggiungendo uno qui è equivalente al numero arrotondamento fino quando intero dividendo (se il bit scartato era 1, viene incrementato il risultato intero-diviso per 1).

Quindi, il bit successivo è di nuovo solo un valore positivo in modo da poterlo determinare normalmente. Ciò significa che vogliamo un loop che calcola due bit alla volta, alternando l'arrotondamento e l'arrotondamento per il numero rimanente, ma vogliamo inserire il loop nel mezzo, quindi iniziamo con l'arrotondamento.

Come possiamo gestire numeri interi negativi? Il problema è che la Fissione non può davvero fare l'aritmetica arbitraria su numeri interi negativi, perché le masse sono sempre non negative. Quindi si dovrebbe fare qualcosa di veramente complicato come lavorare con la grandezza e tenere traccia del segno da qualche altra parte. Tuttavia, la rappresentazione negabinary di un numero negativo può essere calcolata in base a un numero positivo correlato:

Se n è negativo, calcolare la rappresentazione negabinary di n / 2 (arrotondato per eccesso ) e aggiungere la parità di n .

Questo è esattamente il primo passo del nostro loop a due bit. Quindi tutto ciò che dobbiamo fare è avviare il ciclo in un punto diverso se il segno è negativo.

La maggior parte dei risparmi dai 173 byte originali derivava da queste intuizioni che mi hanno permesso di comprimere tre controlli di parità e un ciclo a due sezioni in un singolo ciclo con un unico controllo di parità.

Questo post richiederà troppo tempo se spiegherò tutto il codice in dettaglio, ma indicherò alcune sezioni per fornire il layout approssimativo del flusso di controllo e puoi risolvere i dettagli con il riferimento Fission.

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

A partire da D, questo legge un bit di segno nell'energia e la grandezza nella massa di un atomo che finisce nel [(andando a destra). Questo bit di segno si alternerà dopo ogni passaggio attraverso il controllo di parità e determinerà se manteniamo la metà arrotondata per difetto o per difetto dell'ingresso del loop.

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

Questo è il loop che calcola i singoli bit e inserisce la metà corretta nella successiva iterazione. Il Se il Jsono usati per creare una copia della metà destra in base al bit del segno corrente, i Xs fanno la copia. Il >nell'angolo superiore destro calcola il bit effettivo che viene poi inviato alla pila Kper essere recuperato in seguito. Penso che il layout dell'angolo in alto a destra sia piuttosto ingegnoso e sicuramente vale la pena di studiare in dettaglio se sei interessato a Fission.

Il %è un interruttore che alimenta la parte posteriore numero nel ciclo purché di maggiore di 0.

    O


 M~\
 K/W%

 \{\/
0'A Y

Quando il numero raggiunge 0 viene invece riflesso verso il basso. Questo avvia un altro ciclo che recupera i bit dallo stack, li aggiunge al codice carattere di 0e li stampa con O. Il programma termina quando lo stack è vuoto, perché l'atomo di controllo finirà per essere spinto sullo stack (e in seguito non ci sono più atomi mobili rimasti).

Task 5, Preludio, 219 179 96 byte

Pagina di Esolangs per Prelude.

Interprete Stack Snippet per Prelude.

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

Questo è iniziato come un programma Prelude standard a uscita fissa realizzato a mano con tre voci. Dopo alcune chiacchiere con Sp3000 ho deciso di provare una sola voce. Si è scoperto che ha funzionato abbastanza bene, perché è molto più facile riutilizzare le lettere più vecchie. Quindi Dennis mi ha dato alcuni suggerimenti e ho trovato la versione attuale: l'idea è di spingere tutti gli offset dalla lettera hsulla pila di una singola voce in ordine inverso, quindi stamparli uno alla volta in un ciclo. hviene scelto perché non esiste alcun valore hnella stringa (il che è importante, altrimenti l' 0offset terminerebbe il ciclo) e perché minimizza la codifica degli offset in termini di offset a due cifre e negativi.

La codifica offset è stata generata con questo script CJam .

Task 8, Mathematica, 28 byte

LongestCommonSequence@##==#&

Sì per i built-in. (Denominazione di Mathematica è un po 'strano ... qui LongestCommonSubsequencetrova la più lunga comune sottostringa mentre LongestCommonSequencereperti la più lunga comuni sottosequenza .)

Attività 9, J, 1 byte

*

Come le risposte APL e K, ma sembra che nessuno abbia ancora preso J.

Task 10, Retina, 67 60 byte

Repository GitHub per Retina.

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

Ogni riga va in un file separato e <LF>deve essere sostituita con un carattere di nuova riga e <empty>deve essere un file vuoto. Puoi anche inserire tutto questo in un singolo file e utilizzare l' -sopzione, ma ciò non consente ancora l'incorporamento di caratteri di nuova riga <LF>. Potresti emularlo facendo qualcosa del genere

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

Come mostra l'esempio sopra, l'input dovrebbe essere unario. L'idea del codice è quella di creare tre copie dell'input unario (meno 1), ognuna con una copia della riga corrispondente. Quindi ripetiamo ripetutamente gli ultimi nove caratteri davanti a una 1fino a quando tutte le 1s sono scomparse, ripetendo così le righe se necessario. Infine, rimuoviamo il trascinamento estraneo ~.

Eh, inizierò con una coppia immagino. Prima volta a golf.

Attività 1, Python, 38 21 byte

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

Somma un elenco di tutti i cubi fino a x. Espressione modificata grazie a xnor

Attività 2, TI-Basic 89, 244 byte

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

Non sicuro al 100% su questo, testerà quando trovo nuove batterie per la mia calcolatrice. isPrime è incorporato, ipart è parte intera (2.3 -> 2)

Attività 3, Perl, 45 34 byte

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

file perl 1 2 3 4 -> 2. Salvato un paio di byte grazie a @nutki. Stampato anziché salvare su variabile, quindi stampa variabile.

Task 4, Ruby, 43 40 byte

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

Almeno funziona in 1.9, non so di 1.8. In binario, '10' * 16 (o 2863311530) più un numero, xo con quel 10101010 ... è il negbinary. Emette una rappresentazione in formato stringa tra virgolette (3 -> "111" anziché 3 -> 111). Non riesco a trovare la matematica per scrivere x con meno caratteri.

Task 5, Malbolge, 682 354 byte

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

Prova online qui Pensa che sia breve come andrà. Ho giocato a golf il più possibile. 300 byte salvati, quindi?

Attività 6, bash, 62 50 40 byte

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

Ho scoperto% j da un altro post.

Attività 10, Befunge-98, 121 byte

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

Modificato in befunge-98. Vecchio era Befunge-93, 227 157 147 byte. Funghi usati , scritti in Haskell per i test. Ho usato "do più volte k" e aggiungendo singoli caratteri alla pila con '. Ho la sensazione che possa essere golfato fino a 110 o meno, ma ho già passato troppo tempo su questo ...

Prima cosa: l'attività 6 tecnicamente NON conta; Ho caricato unc meno di un'ora fa. Tuttavia, l'ho quasi caricato stamattina, ma ho deciso di scrivere prima una suite di test. Idiota.

Quindi, comunque, ecco qui!

Si noti che la maggior parte delle cose unc sono intenzionalmente all'indietro, quindi in &&realtà significa ||e così, motivo per cui alcune operazioni sembrano strane (ad esempio, usare -per calcolare il cubo).

Attività 1, Haskell, 21 byte

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

Attività 2, Hy, 135 byte

(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)))

Task 3, Dart, 37 byte

La mia prima funzione Dart!

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

Attività 5, INTERCAL, 1047 byte

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

Attività 6, unc, 157 byte

!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#']:>>

Attività 8, rs, 42 byte

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

Dimostrazione dal vivo.

Attività 10, Pyth, 46 byte

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

Dimostrazione dal vivo.

Attività 1, APL, 7 byte

+/3*⍨⍳⎕

Puoi provarlo online usando ngn / apl, anche se funzionerà con qualsiasi implementazione APL che ha come impostazione predefinita un'origine indice 0.

Questo cuba ogni numero intero da 0 a input ( ⍳⎕) -1 trasferendo ( ⍨) gli argomenti all'operatore di potenza ( *). Il vettore risultante viene ridotto di summing ( +/) e viene restituito uno scalare.

Task 2, Julia, 42 byte

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

Questo crea una funzione anonima che accetta numeri interi come input e restituisce un valore booleano. Per chiamarlo, dagli un nome, ad esf=n->... .

Innanzitutto utilizziamo la funzione integrata di Julia isprimeper verificare se nè primo. In tal caso, controlliamo che log2(n+1)sia un numero intero. Se è così, npuò essere scritto come 2^k-1per alcuni k, e quindi nè un numero primo di Mersenne.

Task 3, ELI , 19 byte

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

Questo crea una monade f che restituisce la mediana del vettore di input.

Ungolfed + spiegazione:

{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)
]}

Esempi:

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

Task 4, Ottava, 39 byte

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

Ciò crea un handle di funzione che accetta un numero intero come input e restituisce la stringa negabinary associata. Per chiamarlo, dagli un nome, ad esempio f=@..., e corri confeval(f, <input>) .

Puoi provarlo online .

Task 5, CJam, 47 byte

"pneumonoultramicroscopicsilicovolcanoconiosis"

La stringa viene semplicemente stampata su STDOUT. Puoi provarlo online se ti senti così incline.

Attività 6, batch di Windows, 46 byte

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

La variabile %date%contiene la data corrente nel modulo Thu 06/25/2015. Siamo in grado di selezionare il mese e il giorno ottenendo la sottostringa della lunghezza di 5 dopo aver saltato i primi 4 caratteri: %date:~4,5%. Da lì controlliamo solo se è il 1 ° gennaio e diciamo Felice Anno Nuovo se lo è.

Attività 7, Pyth, 26 byte

=Gr13312 19895FNU64pC.(.SG

Innanzitutto assegniamo Galla gamma 13312 fino a 19894 inclusi. Quindi eseguiamo il loop 64 volte e ad ogni iterazione riordiniamo G( .SG), rimuoviamo e restituiamo l'ultimo elemento ( .() e stampiamo la sua rappresentazione del carattere ( pC).

Puoi provarlo online .

Task 8, Ruby, 36 byte

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

Questo definisce una funzione fche accetta due stringhe ae b, dove si atrova la stringa da trovare all'internob .

Tutto tranne i caratteri in avengono rimossi bdall'uso .tr()e controlliamo se il risultato contiene aesattamente l'utilizzo []. Questo restituirà nilse la stringa non viene trovata, quindi possiamo ottenere un valore booleano usando !con .nil?.

Attività 9, R, 16 byte

function(x,n)n*x

Questo crea un oggetto funzione senza nome accetta qualsiasi tipo di matrice o matrice xe un intero ne moltiplica ogni elemento di xby n. Se lo desideri, puoi provarlo online .

Attività 10, Python 3, 92 byte

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

Abbastanza diretto. Puoi provarlo online .

Attività 1,> <>, 10 + 3 = 13 byte

::*-:*4,n;

Esegui questo utilizzando l' interprete Python ufficiale usando il -vflag (al costo di 3 byte). Ciò quadra la quantità (n - n*n)e divide per 4, che ovviamente equivale a quadratura (n*n - n)e divisione per 4.

Attività 2, GAP, 63 62 byte

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

(Hai salvato uno spazio scrivendo l'uguaglianza al contrario.)

Attività 3, R, 43 39 byte

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

Grazie a Plannapus per il bel miglioramento!

Task 4, Piet, 155 135 115 5 * 19 = 95 codici

Prova usando questo interprete online , con dimensione del codice 13. O usa il tuo interprete preferito - fammi sapere se ne hai uno che ti piace!

Rendendolo output 0invece della stringa vuota per l'input0 era scomodo. Ho usato un if-then vicino all'inizio per occuparmi di questo caso; quindi un ciclo while per calcolare le cifre nel caso diverso da zero, e infine un altro ciclo while alla fine per emettere le cifre dallo stack.

Mille grazie a Sp3000 per alcuni commenti molto utili, che mi hanno aiutato a salvare alcuni codici!

Task 5, Lua, 52 byte

print"pneumonoultramicroscopicsilicovolcanoconiosis"

Puoi provarlo qui .

Task 6, LaTeX, 157 139 136 127 128 byte

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

Se il prodotto del giorno e del mese è 1, stampare il messaggio; altrimenti, niente. (Il giorno di Capodanno è particolarmente conveniente per questo progetto: poiché l'output che stiamo cercando è 1, abbiamo solo bisogno di orun'istruzione. L' istruzione nth orspecifica il comportamento per il valoren .)

Nota: nella mia versione precedente mancava il ritorno di linea, che era un errore. (Ho provato a testare questa funzione, ma per testarla correttamente potrebbe richiedere del tempo ...)

La mia versione originale utilizzava il calcpacchetto, che era molto più conveniente della mia versione attuale. Qualcosa da tenere a mente per la "vita reale"!

Task 7, Ruby, 62 byte

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

Attività 8, JavaScript, 78 byte

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

Soluzione ricorsiva, verificando se si ltratta di una sottostringa di m. Se lè vuoto, i !lrisultati vengono visualizzati truee la funzione termina. (In questo caso, l[0]non è definito, ma JavaScript è OK con quello.) Altrimenti, cerca la prima istanza di l[0]in m. Se non ne trova uno, allora m.indexOf(l[0])risulta -1e quindi urisulta0 e la funzione termina.

Altrimenti, elimina la prima voce di le le prime uvoci di me continua a controllare.

Task 9, Python, 72 60 byte

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

Esegue il drill-down fino al "livello più basso", dove anon esiste più un elenco, ma solo un numero intero, quindi esegue la moltiplicazione.

Mille grazie a Dennis per avermi salvato 12 byte!

Task 10, Groovy, 81 byte

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

Provalo qui . Inizialmente ho cercato di implementare qualcosa come il .join()metodo di Python per le stringhe, che mette insieme le stringhe con una particolare "stringa di collegamento" (come i collegamenti tra vagoni ferroviari). Ma questo costa molto di più di quanto abbia risparmiato.

Spero di non aver infranto nessuna convenzione per risposte accettabili in queste varie lingue, ma per favore fatemi sapere se ho.

Grazie a Dennis per una fantastica sfida!

Attività 1, Pyth, 5 byte

s^R3Q

Prende il numero dallo stdin. Grazie @Jakube per aver sottolineato l'inutile U.

Attività 6, JavaScript, 56 byte

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

Attività 7, CJam, 16 byte

6581,mr64<'㐀f+

Genera range, shuffle, seleziona prima 64 e mappa l'aggiunta del valore iniziale e la conversione in carattere. 14 caratteri, 16 byte.

Task 8, Ottava, 23 byte

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

Definisce la funzione anonima.

Attività 5, PHP, 45 byte

pneumonoultramicroscopicsilicovolcanoconiosis

Nessuna compressione, solo stampe.

Attività 9, APL 1 byte

 ×

Lo stesso della risposta K.

Attività 1, R, 21 19 byte

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

Abbastanza semplice. Ingresso da STDIN.

Attività 2, Perl, 40 66 byte

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

Aggiunto un controllo primo (regex di controllo del numero primo di Abigails)

Task 3, PARI / GP, 24 22 byte

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

La prima volta che l'ho toccato. Potrebbe dover imparare un po 'di più.

Attività 4, T-SQL, 235 byte

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

Funzione tabella in linea che utilizza CTE ricorsivo. Molto grande, ma divertente da fare.

Usare

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

Attività 5, GAP, 48 byte

"pneumonoultramicroscopicsilicovolcanoconiosis";

Attività 6, Excel, 51 48 byte

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

Grazie a @Bond per i 3 byte.

Attività 7, Python 2.6, 98 93 85 byte

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

Questa è la prima volta che provo a fare qualsiasi cosa in Python, quindi potrebbe essere molto meglio. Grazie @Dennis e @Jacob per gli ottimi consigli

Attività 8, TCL, 57 byte

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

Peccato che la rimozione di spazi bianchi uccida questo

Task 9, Pike, 53 byte

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

Una funzione che restituisce l'array moltiplicato

Task 10, Powershell, 88 byte

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

Una funzione Powershell. Penso di poterlo abbreviare un po ', ma eccolo qui al momento.

E finalmente finito :)

Attività 2, J, 10 byte

1&p:*/@,#:

Prepara uno 0 o 1 booleano se l'input è primo nella sua rappresentazione binaria, quindi accetta il prodotto. Funziona sulla versione corrente di J.

Attività 5, HTML, 45 byte

pneumonoultramicroscopicsilicovolcanoconiosis

Task 6, pesce, 53 byte

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

Basato sulla risposta bash.

Attività 8, APL, 12 byte

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

Questa è un'espressione di funzione. Confronta l'ordine dei caratteri trovati nella stringa più grande con ciò che ci si aspetterebbe se fossero ordinati.

Attività 9, K, 1 byte

*

Dovrebbe funzionare in qualsiasi versione. Le operazioni aritmetiche si distribuiscono su array.

Attività 1, Ruby, 40 byte

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

La prima volta che scrivo qualcosa in Ruby. Testato con rubino 1.8.7.

Attività 2, R, 50 byte

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

Calcola p, controlla se è un numero intero e se n e p sono numeri primi.

Attività 5, PostgreSQL, 54 byte

SELECT'pneumonoultramicroscopicsilicovolcanoconiosis';

Task 6, Lua, 55 byte

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

Task 8, Python, 65 byte

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

Uso:

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

Task 10, Julia, 73 byte

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

Grazie a @AlexA. per aver contribuito a ridurre questo codice! Esempio di uscite:

julia> f(0)




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

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

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

Attività 1, Haskell, 17 byte

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

Task 2, Mathematica, 30 byte

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

Attività 3, JavaScript, 46 byte

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

Attività 5, MATLAB, 47 byte

'pneumonoultramicroscopicsilicovolcanoconiosis'

Task 6, Ruby, 56 byte

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

Task 7, Python, 106 byte (rientro con \t)

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

Si noti che l'utilizzo diretto di list(set(s))non non funziona qui come questo causerà una distribuzione di probabilità non uniforme nello spazio di tutte le possibili stringhe a causa di ri-ordinamento dei membri della lista.

Attività 1, Haskell, 15 byte

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

Task 2, Julia, 28 byte

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

Task 3, Ottava, 30 byte

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

Task 5, Yacas , 45 byte

pneumonoultramicroscopicsilicovolcanoconiosis

Task 6, Mathematica, 46 byte

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

Attività 9, PARI / GP, 10 byte

(n,a)->n*a

Attività 3, Clip, 13 byte

gHk[tivt}l`sk

Un'altra versione:

gHkci`v``l`sk

Il ` sembrava costo troppo.

Task 4, KSFTgolf, 16 byte

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

L'interprete è qui.Non sono sicuro di quello che sto facendo ... Stamperà il negabinary e poi andrà in crash.

C'è un bug nell'interprete. O sarò in grado di golf fino a 12 byte usando la conversione di base integrata (ma funziona solo con numeri interi positivi):

2*02-ba'Z=;x

Versione originale CJam:

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

Ho provato Pip, Struzzo, Clip e Burlesque per scoprire se esiste un esolang con negabinary incorporato. Nessuno di loro ha funzionato. KSFTgolf usatonumpy , che sembrava avere un comportamento strano e strano quando la base era negativa. Ma non è facile farlo funzionare con numeri non positivi.

Attività 7, CJam, 15 byte

'䶶,DAm<>mr64<

Attività 8, APL, 21 byte

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

Provalo online.

Attività 2, maschera x86, 40 byte

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

(escluso intestazione, MessageBox, ecc. - solo byte rilevanti)

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

Attività 3, C, 136 byte

#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]);}

Compilare usando gcc -o Prime main.c

Attività 10, C ++, 478 byte

#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);}

Compilare usando g++ -o Trucks main.cpp

C & C ++ può essere abbreviato ma aggiungerebbe un errore del compilatore. Non conosco le regole esatte, quindi ho provato a lasciare il codice senza errori del compilatore.

Attività 1, Python, 35 byte

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

Attività 3, CJam, 9 byte

q~$_,(2/=

Attività 4, JavaScript, 55 53 byte

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

Attività 5, Pyth, 46 byte

"pneumonoultramicroscopicsilicovolcanoconiosis

Attività 6, C #, 65 byte

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

Attività 1, jq, 24 byte

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

Task 6, PostgreSQL, 54 byte

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

Attività 1, Cjam, 7 byte

q~,:+_*

Modifica: ho appena notato che Martin l'ha pubblicato prima di me. Proverò qualcos'altro ...

Task 3, Python, 30 byte

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

Python 2.

Attività 5, ///, 45 byte

pneumonoultramicroscopicsilicovolcanoconiosis

/// farà eco a qualcosa senza /caratteri.

Task 7, Pyth, 19 byte

s>64.SmC+13312d6582

Programma. Per favore, dimmi se ho fatto i conti con la matematica. Provalo qui

Task 9, Ottava, 9 byte

@(a,n)a*n

Maniglia di funzione anonima. Octave lo fa automaticamente con matrice * scalare.

Non ho trovato il tempo di provarli tutti, ma ecco un inizio

Attività 1, cc, 8 byte

d1+*d*4/

Input e output in cima allo stack, come da dcconvenzione.

Task 5, Emacs Lisp, 46 byte

'pneumonoultramicroscopicsilicovolcanoconiosis

Abuso delle regole:

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

Il migliore che ho potuto gestire scompattando dalla forma compressa era 55, in Perl:

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

(i caratteri non stampabili sopra vengono confusi da SE, ma poiché in realtà non è la mia risposta, non lo sto riparando)

Attività 6, SQL, 54 byte

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

Considero i primi dieci giorni di gennaio come giorni "appropriati" per questo saluto, ma puoi adattarti ai gusti. Il now() LIKEcostrutto risulta più breve dell'estrazione del giorno dell'anno con DATE_FORMAT(now(),'%j').

Task 10, sed, 58 byte

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

Ingresso in unario.

Task 5, MarioGolf , 50 byte

Questa era una lingua che ho sviluppato da tempo.

La versione attuale ha funzionalità sufficienti per consentire di eseguire questa sfida.

Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O

Puoi provarlo online su http://htmlpreview.github.io/?https://raw.githubusercontent.com/ismael-miguel/mariogolf/master/js/testpage.html#c:Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O

Attualmente, lo sviluppo viene interrotto e l'implementazione è incompleta.

L'ultimo commit è stato il 13 marzo 2015.

Attività 6, PHP, 37 byte

Questo è davvero facile e divertente!

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

Compito 10, Javascript, 121 byte

Sì, non così golf ...

Ma fa il lavoro!

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

Provalo:

//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>

Il codice non verrà visualizzato bene nello snippet dello stack poiché inizia con "l'output. Gli spazi pubblicitari sono stati aggiunti per compensarlo.

Il codice originale può essere eseguito sulla console di Chrome senza alcun problema e l'output sarà quello previsto.

Attività 1, CJam, 10 byte

li,{3#}%:+

Prova qui

Task 5, Retina, 46 byte

<empty>
pneumonoultramicroscopicsilicovolcanoconiosis

Task 1, Ottava, 15 byte

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

EDIT: Pensavo di averlo aggiunto, ma sembra che mi sia dimenticato di salvare: questo usa il fatto che sum(1^3+2^3+3^3+...+n^3) = sum(1+2+3+...+n)^2 = [n*(n+1)/2]^2

Attività 3, Javascript, 24 byte

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

Bene, prima facciamo le cose semplici:

Attività 5, ASP, 45 byte

pneumonoultramicroscopicsilicovolcanoconiosis

Attività 6, JavaScript, 46 byte

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

Attività 1, VBA, 126 byte

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

Non ho idea di come giocare a golf in VBA. Non ho digitato un singolo spazio, VBA inserisce automaticamente gli spazi bianchi.=f(5)in una cella in Excel verranno visualizzati 100.

Attività 2, ottava, 32 byte

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

Task 5, Golfscript, 47 byte

"pneumonoultramicroscopicsilicovolcanoconiosis"

Attività 9, MATLAB, 9 byte

@(A,n)A*n

Bene, è un inizio ...