È necessario completare quattro attività in una lingua che:

• non deve restituire risultati * quando viene cercato su questo sito Web (codegolf.se), ad esempio ToffeeScript ;
• deve avere una pagina elencata su Esolang , Rosetta Code o Wikipedia ;
• essere un linguaggio distinto, piuttosto che una versione distinta (ad esempio python 2.1 sarebbe valido se python soddisfacesse i primi due criteri).

* L'eccezione è questa hit per ToffeeScript.

Le quattro attività da completare sono:

1) Scrivi una descrizione tweetable (<140 caratteri) / promozione della lingua scelta.

2) Stampa "Hello World! Questo è scritto in <programming language name>."

3) Stampa tutti i numeri dispari in un intervallo specificato dall'utente. (es. uno stdin di 20 25dovrebbe tornare 21 23 25).

4) Scrivi un programma che ritieni migliore dimostri una caratteristica interessante della lingua scelta.

punteggio:

• Questo è un concorso di popolarità
• Bonus di 10 punti se elencato in due delle precedenti directory, 25 se in tutte e tre.
• Il punteggio è la somma dei voti ricevuti a mezzanotte UTC il 1 luglio 2015, più i bonus.

chiarimenti:

• L'attività 1) può essere un programma tweet, ma è accettabile anche il testo normale.
• Molte lingue non hanno un interprete esistente; le soluzioni a questi vanno bene, ma saranno prese in buona fede.
• Il secondo criterio per la scelta della lingua proibisce le pagine la cui creazione risale a questo post. Se, per una determinata lingua, X, esiste una soluzione a un problema su Rosetta Code ma non ha una pagina distinta da qualche parte, è comunque accettabile.

Bloop

Bonus: 10

Ci sono pagine per BlooP su Esolangs e Wikipedia . Una ricerca PPCG per BlooP non restituisce risultati. Se vi sentite particolarmente Loopy, si può provare su repl.it .

Compito 1: il Tweet

BlooP: nient'altro che loop limitati. ;) #programmazione #goodtimes

Questo utilizza uno stile Twitter standard che include hashtag ed emoticon. Ciò piacerebbe a qualsiasi utente di Twitter. *

Compito 2: Hello World

DEFINE PROCEDURE ''GREETING'' [N]:
BLOCK 0: BEGIN
  PRINT['Hello World! This is written in BlooP.']
BLOCK 0: END.

GREETING[0];

Come puoi vedere, questo è un linguaggio di golf privilegiato. *

Attività 3: I numeri dispari

DEFINE PROCEDURE ''IS-ODD'' [N]:
BLOCK 0: BEGIN
  OUTPUT <= 0;
  CELL(0) <= 2;
  LOOP AT MOST N+1 TIMES:
  BLOCK 1: BEGIN
    IF N+1 = CELL(0), THEN:
    BLOCK 2: BEGIN
      OUTPUT <= 1;
      ABORT LOOP 1;
    BLOCK 2: END;
    CELL(0) <= CELL(0) + 2
  BLOCK 1: END;
BLOCK 0: END.

DEFINE PROCEDURE ''ODDS-IN-RANGE'' [A,B]:
BLOCK 0: BEGIN
  CELL(0) = A;
  LOOP AT MOST B TIMES:
  BLOCK 1: BEGIN
    IF CELL(0) > B, THEN:
    ABORT LOOP 1;
    IF IS-ODD[CELL(0)] = 1, THEN:
    PRINT[CELL(0)];
    CELL(0) <= CELL(0) + 1;
  BLOCK 1: END;
BLOCK 0: END.

ODDS-IN-RANGE[20,25];

Gli unici operatori disponibili in BlooP sono assegnazione ( <=), addizione, moltiplicazione, maggiore di, minore di e uguale. A causa della sua sintassi dolorosamente dettagliata, in realtà è abbastanza facile dire cosa sta succedendo anche senza una profonda comprensione della lingua.

Compito 4: l'interessante

Nota: il mio frammento di questo compito è soggetto a modifiche se dovessi trovare qualcosa di più interessante.

DEFINE PROCEDURE ''MINUS'' [M,N]:
BLOCK 0: BEGIN
  IF M < N, THEN:
  QUIT BLOCK 0;
  LOOP AT MOST M + 1 TIMES:
  BLOCK 1: BEGIN
    IF OUTPUT + N = M, THEN:
    ABORT LOOP 1;
    OUTPUT <= OUTPUT + 1;
  BLOCK 1: END;
BLOCK 0: END.

DEFINE PROCEDURE ''FIB''[N]:
BLOCK 0: BEGIN
  IF N < 1, THEN:
  QUIT BLOCK 0;
  OUTPUT <= 1;
  IF N < 3, THEN:
  QUIT BLOCK 0;
  OUTPUT <= FIB[MINUS[N,1]] + FIB[MINUS[N,2]];
BLOCK 0: END.

FIB[10];

Ecco, i numeri di Fibonacci.

* Potrebbe non essere vero

Mond *

• * La ricerca di "Mond" dà un risultato (nonostante questa risposta), ma è un falso positivo e in realtà non menziona la lingua.
• Pagina del codice Rosetta . Questo è stato effettivamente creato dopo la pubblicazione della sfida, tuttavia da settembre 2014 esiste una soluzione per l' attività QuickSort .
• Sebbene mond sia molto simile a JavaScript (in effetti, è abbastanza facile scrivere poliglotti Mond / JS), non è un sottoinsieme, un superset o una reimplementazione. È il suo linguaggio distinto.

Provalo nel tuo browser

Divulgazione completa : sono coinvolto nello sviluppo e nel processo di progettazione di Mond in una certa misura e ho implementato personalmente diverse funzionalità linguistiche importanti, inclusi gli operatori definiti dall'utente, che sono dimostrati nelle attività 3 e 4.

Compito n. 1

L'operatore pipeline ( |>) è lo zucchero di sintassi che trasforma la chiamata di funzione sul lato destro in una chiamata di funzione con il valore sul lato sinistro inserito come primo argomento. foo |> bar()è lo stesso di bar( foo ).

"Simple, elegant scripting language implemented in C# for .NET/Mono" |> printLn();

Compito n. 2

"Hello World! This is written in Mond." |> printLn();

Attività n. 3

Il codice per questa attività presuppone diverse cose:

1. L'intervallo di numeri verrà inserito su una sola riga
2. I limiti superiore e inferiore saranno separati da un singolo spazio
3. I numeri indicati sono numeri interi in base-10 e contengono solo i caratteri 0-9

Provalo qui

// parse a string to a number
fun toNumber( str ) {
    var n = 0, pow = str.length();

    for( var i = 0; i < str.length(); ++i )
        n += ( str.charCodeAt( i ) - 48 ) * ( 10 ** --pow );

    return n;
}

fun map( arr, fn ) {
    var ret = [ ];

    foreach( var item in arr )
        fn( item ) |> ret.add();

    return ret;
}

// user-defined operator to create an upper-bound inclusive range a-la Ruby
// (i.e. 1 .. 5 produces [ 1, 2, 3, 4, 5 ])
seq( .. )( start, end ) {
    for( var i = start; i <= end; ++i )
        yield i;
}

// read a line from STDIN, trim leading and trailing whitespace,
// split the string to an array, map the array to parse all strings to numbers.
var nums = readLn().trim().split( " " ) |> map( toNumber );

// nums[0] .. nums[1] makes use of the user-defined operator declared on line 22.
// nums[0] is the lower bound, nums[0] is the upper bound.
foreach( var n in nums[0] .. nums[1] ) {
    if( n % 2 != 0 ) printLn( n );
}

Compito n. 4

Questa attività dimostra gli operatori definiti dall'utente , che consentono al programmatore di definire qualsiasi operatore arbitrario (purché non esista già) proprio come una funzione e utilizzarlo come farebbe con qualsiasi altro operatore. Vengono in sapori unari e binari.

Provalo qui .

// forward function compositing user-defined operator.
// the function on the right-hand side is called with
// the result of the function on the left-hand side.
fun( >>> )( fn1, fn2 ) {
    return fun( ...args ) {
        return fn1( ...args ) |> fn2();
    };
}

// the mythical "goes down to" operator of legend.
// a lazy sequence that returns all numbers starting from 'hi'
// down to (and including) 'lo'
seq( --> )( hi, lo ) {
    for( var i = hi; i >= lo; --i )
        yield i;
}

seq map( iterable, callback ) {
    foreach( var item in iterable )
        yield item |> callback();
}

// doubles the value of n
fun double( n ) -> n *  2;

// squares the value of n (** is the power operator, a-la Python or Ruby)
fun square( n ) -> n ** 2;

// gets the sequence for 10 down to 0, passes it into
// map, which maps it through the composited function of
// double and square, which first doubles the given value
// then squares it.
var nums = ( 10 --> 0 ) |> map( double >>> square );

foreach( var n in nums )
    printLn( n );

JQ

Nessuno dei 14 risultati su codegolf.se riguarda la lingua. ( jq(e varianti maiuscole) sembra essere un'istruzione frequente in Pyth.)

C'è una categoria jq sul codice Rosetta .

Puoi provarlo online ma alcuni degli esempi seguenti richiedono l'ultima versione 1.5.

Compito 1: il Tweet

jq è come sed per JSON; puoi usarlo per elaborare dati strutturati con la stessa facilità con cui sed, awk, grep e friends ti permettono di giocare con il testo

(Senza vergogna ha smentito il primo paragrafo dal suo sito.)

Compito 2: Hello World

bash-4.3$ jq -n -r '"Hello World! This is written in jq."'
Hello World! This is written in jq.

Attività 3: I numeri dispari

bash-4.3$ jq -R 'split(" ") | range(.[0] | tonumber; .[1] | tonumber + 1) | select(. % 2 == 1)' <<< '20 25'
21
23
25

Compito 4: l'interessante

Il file ~ / .mozilla / firefox / *. Default / extensions.json contenente informazioni sulle estensioni di Firefox installate ha 0 nuove righe in 171 Kb sui dati JSON, il che rende in qualche modo difficile la lettura.

Stampa piuttosto i dati JSON:

bash-4.3$ jq '' ~/.mozilla/firefox/*.default/extensions.json

Doh. Le linee 8000 ++ sono troppo lunghe, quindi passale al cercapersone, ma mantieni l'evidenziazione:

bash-4.3$ jq -C '' ~/.mozilla/firefox/*.default/extensions.json | less -r

Ahia. Quante estensioni ci sono comunque?

bash-4.3$ jq '.addons | length' ~/.mozilla/firefox/*.default/extensions.json
58

Ok, ma alcuni sono disabilitati. Quanti esattamente?

bash-4.3$ jq '[.addons[] | select(.active | not)] | length' ~/.mozilla/firefox/*.default/extensions.json
7

Alcuni sono abbastanza abbandonati e non funzionano più con l'attuale Firefox:

bash-4.3$ jq -r '.addons[] | [.defaultLocale.name, (.targetApplications[] | select(.id == "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}"))] | select(.[1].maxVersion | gsub("[^\\d.]"; "") | tonumber < 38.0) | .[0]' ~/.mozilla/firefox/*.default/extensions.json
Unity Desktop Integration
Unity Websites integration
Ubuntu Firefox Modifications

(Questo in seguito non è vero.

OOC

Sì, sono in ritardo di circa un mese. E allora???

• La ricerca di ooc al momento non dà risultati.
• Link a ooc al codice Rosetta .

Compito 1

ooc è un linguaggio di programmazione che si compila fino a C99 che ha una sintassi elegante e supporta lo sviluppo sia di alto che di basso livello.

135 byte! C'è mancato poco!

Inoltre, falsi punti bonus per il logo follemente ASCII di Ooc :

           +(NNhBBhss+'                  ~+'(sNBND=~.         
           -(=NDhNN+=+=' .   .  .    . .+='+~DNND+=.          
           .+-DBDDh+(D-<'      .....  -<+ (=~DNh+<(           
            '+<NNNB=~=z-(<-<<(+('-'~<<=- .+'sBNh~+            
             (~=NNND+=DB~(-.    . .    ...(=BNB+s--      ALL YOUR 
             .=-=DBDz-'~. .   ..'. .... '  '~s<<szh<.         
               <(~'. .  .  ..sD='-~'-'-DDs.. . .~sD(     CODEBASE  
            . ~+'  '  .-(-..sBNB~(~~+=hNNNz'<<z='-z(               
           . .=. -DDz<~s~  'BNNN=~+<shNNNND(sNNNh~(+    ARE BELONG
            .=<.(NNNNDDs. (hhs+=s=hNDNNBNBBs<BNND<<=.             
            .'-'~sNNs((- .''. ' -~NNDz+((~---~sB<'''.     TO US!
                '=(++(-..  . ...-~+B~'....'.''-+(     .             
                -=z<<'.. .'-...'-~hz~-'.''''-~-<=                     
                 .~+~s~  ~z<~'-'--hN=~((~'---(~~z~                    
                   (+<-.'+=''''~(+=Bz--~(((=+s+~(s                     
  IT'S OVER      . '+-..~<----~-+(sBNh+zBNNBNh+<z'                     
                   .<-'--''(<~=B=hDDD=<<<++=++<=.                   
  9000 BUGS!     .. s~..'h=++ss=D<<~+B(<(+<=Nz=+                     
                    +'.''+NNDN(+z(((sB<((s+hNh<+             
                   .= -~(~(zDNz+z+zhNDz=szhhBz++.       MADNESS?        
                   '+. ss<'~=NBNBBDzBzhshDD=+<<-                   
                   -= . +s~-(+==hhDBNBDDs==hz+<     THIS! IS! LLAMA!
                 '(<-  . '~~(<+<=+<sz=+sshzs(..               
                .+<.    '('-~(((((<++(<<((= .                 
                 .--.. ....'.'.'.'..''..'-..

Compito 2

"Hello, world!" println()

Compito 3

import text/StringTokenizer
import structs/ArrayList
input := stdin readLine() split(' ', false)
(begin, end) := (input[0] toInt(), input[1] toInt())
for (i in begin..end+1) {
    if (i % 2 != 0) { "%d " printf(i) }
}
println()

Implementazione piuttosto semplice. Inoltre, questo mostra un aspetto interessante di ooc: le chiamate di metodo usano gli spazi come delimitatori, non punti. Ad esempio, si noti stdin readLine() split(' ', false)sopra. Nella maggior parte delle lingue, sarebbe scritto come stdin.readLine().split(' ', false), ma ooc lo riserva per il concatenamento delle chiamate (scorrere verso il basso fino all'esempio di codice).

Compito 3

Questo mette in mostra la mia funzione ooc preferita: corrispondenza dei tipi. È come la corrispondenza del modello. In una lingua OO. Eccezionale.

import structs/ArrayList
import math/Random

Animal: abstract class {
    makeNoise: abstract func
}

Sheep: class extends Animal {
    init: func
    makeNoise: func {
        "Baaaaaaa!" println()
    }
}

Wolf: class extends Animal {
    init: func
    makeNoise: func {
        "Hooooowl!" println()
    }
}

animals := [Sheep new(), Sheep new(), Sheep new()] as ArrayList<Animal>
badNumber := Random randRange(0, 3)
animals[badNumber] = Wolf new()
animal: Animal

"Enter a number between 0 (inclusive) and 3 (exclusive)" println()
inputNumberString := stdin readLine()
for (chr in inputNumberString) {
    if (!(chr.digit?())) {
        "NUMBER, not CHARACTER! Can't you read!?" println()
        exit(1)
    }
}
inputNumber := inputNumberString toInt()
try {
    animal = animals[inputNumber]
} catch (e: OutOfBoundsException) {
    "I said a number between one and three, you idiot!" println()
    exit(1)
}
"Animal noise:" println()
animal makeNoise()
match (animal) {
    case sheep: Sheep => { "It's a stupid, annoying sheep!" println() }
    case wolf: Wolf => { "AHH! A WOLF! You got eaten. :/ R.I.P." println() }
}