Ciao mondo! con personaggi semi-comuni


28

Come alcuni di voi sapranno, per ottenere una lingua sul meraviglioso Provalo online di Dennis ! , ciao, mondo! è richiesto il programma. Di recente, Dennis ha fatto un passo avanti per caricare questi programmi dal sito Web. Ecco una pastebin JSON dei personaggi utilizzati in quei programmi, per frequenza, a partire dal 27 luglio 2017.

Alcuni di quei personaggi hanno bisogno di un po 'd'amore, quindi la tua sfida è quella di produrre Hello, World! (preferibilmente in una lingua coinvolta in questo processo), utilizzando solo i caratteri specificati di seguito. Questi personaggi sono tutti i personaggi usati tra 10e 99(compresi) i tempi, insieme ai due personaggi più comuni 0e , perché mi sento bene.

0 $&*?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_

L'utilizzo del personaggio dovrebbe essere basato sul suo aspetto in un normale programma, non sulla base del suo punto di codice o valore byte.

È necessario utilizzare almeno un carattere di quel set, quindi i programmi di lunghezza 0 non sono validi.

Questo è , quindi vince la risposta più breve in byte.

JSegnala per verificare se la tua risposta è valida


posso emettere uno spazio nella riga successiva?
dzaima,

@dzaima Se non puoi emetterlo senza lo spazio, fallo. Se sbarazzarsi dello spazio utilizza solo più byte, sbarazzarsi dello spazio
Stephen

Esiste un consenso della comunità (o un'indennità / dismissione specifica qui) sui caratteri non stampabili che si fanno strada nell'output (STDOUT)? Non sono sicuro di averlo visto emergere prima (e sarebbe facilmente trascurato) ma qui cambia radicalmente la mia strategia ...
brhfl

@brhfl non di cui io sia a conoscenza - l'unica norma è che di solito sono consentite nuove righe finali, si potrebbe chiedere in chat
Stephen

Risposte:


6

SOGL V0.12 , 89 75 68 byte

z{}xxxx≥x≥x≥xXUqXxq≤qq≤q *R_IIRq  q *R_I0II*IRqxXq≤qxqxq CR_0II÷Rq0*

Provalo qui!
Nota: ogni volta che qo l'output viene indicato qui, non viene visualizzato come output di pop-up (nessuno dei oOpP) non è disponibile o emette una nuova riga prependente.

Spiegazione (obsoleto, ciò che è cambiato è che la "H" è stampata usando le lettere alfabetiche):

 $             push "$"
  R_           convert to an array of ordinals, then push all the contents to the stack
    0II        push 0+1+1 = 2
       *       multiply by that
        R      convert to character
         q     output
          z    push the lowercase alphabet
           {}  iterate over it, pushing each char, and do nothing. Stack: ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
stack manipulation:
 xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"]
 ≥    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"]
 x    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"]
 ≥    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
 x    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"]
 ≥    ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"]
 xxx  ["l","o","r","H","a","b","c","d","e"]
 q    output the "e"
 ≤    ["o","r","H","a","b","c","d","e","l"]
 qq   output the "l" twice
 ≤    ["r","H","a","b","c","d","e","l","o"]
 q    output the "o"

*                       push "*",
 R_                     convert to an array of ordinals, then push all to stack
   II                   increase by 2
     R                  convert back to character
      q                 output
         q              push a space, then output
           *            push "*"
            R_          convert to an array of ordinals, then push all to stack
              I         increase that
               0II      push 0+1+1 = 2
                  *     multiply
                   I    increase
                    Rq  output as character
stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"])
 x  ["r","H","a","b","c","d","e","l","o",","]
 X  ["r","H","a","b","c","d","e","l","o"]
 q  output the "o"
 ≤  ["H","a","b","c","d","e","l","o","r"]
 q  output the "r"
 x  ["H","a","b","c","d","e","l"]
 q  output the "l"
 x  ["H","a","b","c","d"]
 q  output the "d"

C            push "C"
 R_          convert to ordinal as before
   0II÷      floor divide by 2
       Rq    output as character
         0*  multiply by 0 so nothing extra would be outputted

Curiosità: tutti i personaggi dei personaggi ammessi sono nella tabella codici SOGL: D


Quindi ... Hai un buon lavoro stabile come sviluppatore professionista, giusto? Perché dang, questo è un bel linguaggio ... Anche un buon interprete JS, l'hai finito ieri sera :)? Puoi iniziare a pubblicare documentazione per alcune delle lingue? O la chat privata mi segnala la posizione di tale documentazione? SOGL lo uccide.
Magic Octopus Urn

@MagicOctopusUrn 1) no lol Sono 15 2) Personalmente non mi piace perché il modo in cui è realizzato è la cosa più corporea che ho fatto 3) L'interprete JS è stato lì per un po '4) gli ultimi documenti su SOGL (se li puoi chiamare così) sono qui , attraverso alcune cose (come le palenChars.txt) sono più aggiornate qui
dzaima

Congratulazioni per aver nuovamente ridotto il conteggio dei byte! Onestamente non penso di poter abbassare il mio !!
Dom Hastings,

23

Perl 5 , 76 byte

}{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\*G

Questo utilizza una funzione che è stata deprecata, ma funziona localmente nel mio terminale (che è la versione 5.18.2 come notato). Nelle versioni precedenti di Perl ?\w?è un sinonimo per il /\w/quale mi dà accesso alla corrispondenza regexp e ho caratteri sufficienti per $&(ultima corrispondenza) e $`(testo precedente all'ultima corrispondenza). Ho bisogno di questi per essere in grado di ottenere il O. Genero questo creando un globriferimento ( $_=\*Gche, trasmesso su uno scalare, è qualcosa di simileGLOB(0x7ffb728028d0) ). Una volta che è in $_, ?B?corrisponderà al Be $`conterrà GLO, posso quindi corrispondere contro \w$che memorizzare Oin$&che viene inserito nelle stringhe che sto eseguendo in modo stringa-AND per creare il resto del testo, il corpo della stringa viene minuscolato utilizzando \L.

Provalo online! - utilizza /\w/al posto di in ?\w?quanto la versione di Perl su TIO è troppo nuova.


Perl 5 , 65 byte

Questo è un po 'più economico in quanto si basa sul nome del file su TIO (che è .code.tio), quindi non penso davvero che sia in competizione, ma sono stato contento del risultato!

}{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}

Provalo online!


Non ho detto nulla sul contenuto delle bandiere, quindi -pva bene. Ottimo lavoro, questo è quello che speravo quando l'ho chiesto :)
Stephen,

1
come ... cosa ... il ...
Okx

@StepHen sono felice di averlo obbligato! Mi è davvero piaciuto molto questo. Sono contento che tu non stia penalizzando anche la bandiera, aggiornerò il mio post. Grazie!
Dom Hastings

@Okx Sono contento di aver avuto quell'effetto!
Dom Hastings,

Sei sicuro di non aver bisogno di aggiungere 15 byte <3?
Magic Octopus Urn,

10

Unario , 7 * 10 182 byte

Unario è Brainfuck convertito in binario convertito in unario usando 0come contatore. Essenzialmente, condensa un programma Brainfuck in un numero e l'output è quel numero di 0s. Di solito sono programmi molto grandi.

Non incollerò qui il programma perché non so quanto testo consente SE, ma scommetto che è inferiore a questo. Invece, incollerò il numero preciso di zero in questa risposta:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

Poiché questa è una risposta abbastanza economica, garantita per non essere la più breve, e l'ho semplicemente copiata , la sto trasformando in un post wiki.


2
"Non so quanto testo SE consente" almeno non è 7 * 10¹⁸² che è waaaaaay più grande di 65536.
Erik the Outgolfer

9

05AB1E , 137 106 95 byte

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

Provalo online!

-31 grazie a @Adnan per aver sottolineato che potrei usare la base 108.

- ?? grazie a @Riley per aver segnalato alcune cose sbagliate.


Vecchia versione (metodo diverso):

05AB1E , 211 186 166 byte

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

Provalo online!


Haha! E QUI HO PENSATO CHE ESOLANG STOOD NO POSSIBILE POSSIBILITÀ!


Per prima cosa otteniamo 255 memorizzati in X:

00g               # Push 2 (length of 00).
   00000g         # Push 5 (length of 00000).
         00000g   # Push 5.
               JU # Join to 255 and store in X.

Quindi, usando lo stesso trucco di lunghezza spingiamo: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

Dove usiamo 0<space>invece il trucco di lunghezza per gli zeri.

Quindi, infine, spingiamo i 255 che abbiamo archiviato e convertiamo da 255 a base 10 :

X  # Push stored 255.
 B # Convert to base 255.

Continuando a giocare a golf usando gli altri caratteri consentiti e la duplicazione, ci vorrà un minuto.


8

Beatnik , 148 byte

K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA

Provalo online!

Spiegazione

Beatnik basa l'istruzione eseguita in base al punteggio scrabble della parola. Ecco una spiegazione abbreviata:

Code         Scrabble Score   Explanation

K            5                push the scrabble score of the next word
QQQQQQQG     72               72 ['H']
ZD           12               pop a value; push it back twice
XA           9                pop a value; print its ASCII character
KD           7                pop two values; push their sum
Z            10               pop two values; push their difference

8

Moorhens (v2.0), 3423 983 923 866 749 716 byte

Penso che si possa giocare un po 'a golf, Moorhens non è un linguaggio facile con cui lavorare.

xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA

Spiegazione

Moorhens è una lingua basata su parole del dizionario. Ogni parola corrisponde a un'operazione basata sul suo hash. I cinque operazioni di uso qui ci sono xU, ER, XI, KA, eAA

  • xU incrementa il TOS
  • ER mette un nuovo zero nello stack.
  • XI decrementa il TOS
  • KA duplica il TOS
  • AA ruota il TOS verso il basso

Spingiamo ogni lettera con applicazioni successive di queste operazioni.


5
'Le due operazioni' - Non sono esperto di esolang ma sicuramente sono cinque operazioni?
boboquack

@boboquack fixed
Wheat Wizard

1
collegamento alla lingua?
Leaky Nun,


5

Glifo , 480 byte

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

Provalo online!


4

Headsecks , 78 byte

yyzyzzxNxNzx{yyy{y{y{yzzz_{_zzyy\zxxxxxx\zzy\\zz\zx\{{\{{\zzz\xxx\{{\{{y\zzzx\

4

Doppio JavaScript, 318 byte

Non sono sicuro che sia permesso, non potrei farlo usando l'interprete JavaScript una volta. È simile all'uso eval()ma invece sto usando l'interprete due volte: (Provalo nella console per stampare il risultato)

`\`\\x${0xA*0xA&0xC}${0xA&0xC}\\x${0xA*0xF&0xF}${0xB*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}F\\x${0xE*0xF&0xF}C\\x${0xE*0xF&0xF}${0}\\x${0xB*0xF&0xF}${0xB*0xB*0xF&0xF}\\x${0xA*0xF&0xF}F\\x${0xB*0xB*0xF&0xF}${0xE*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}${0xA*0xA&0xC}\\x${0xE*0xF&0xF}${0**0}\``

Provalo online!

Valuta a:

`\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21`

Provalo online!

Che valuta Hello, World!


3

Smallf ** k , 266 byte:

zJ$NJ`ZZx*gQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0*000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{*QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0T*F j$?kCzQk*}U}UgI$}Ew_yDL`qYI*E_G}SCjXDFNJKGNIGyIwA\BzLP`*zCILGCNqyYZyq? GwN{q{gKSj

In realtà, i personaggi sono piuttosto irrilevanti. È solo una questione se ogni personaggio ha o meno un punto di codice pari o un punto di codice dispari. Quindi, ho fatto uno sforzo per usare tutti i personaggi disponibili (tranne i caratteri multibyte) (anche se da quando è stato randomizzato, non ho fatto uno sforzo per garantirlo).


1
@totallyhuman Hai ragione; Lo cambierò. Rimuoverò solo i caratteri multibyte. In realtà non ha una tabella codici; deve solo essere memorizzato come 1s e 0s (1 per pari orde 0 per pari ord) quindi si può dire che questo è 33,25 byte xD
HyperNeutrino

L'utilizzo del personaggio dovrebbe essere basato sul suo aspetto in un normale programma, non sulla base del suo punto di codice o valore byte.
KSmarts,

@KSmarts Chiederò all'OP di questo.
HyperNeutrino,

@KSmarts Ciò significa che se una lingua ha una tabella codici diversa e, ad esempio, '5'occupa il punto codice della normale 'A', non ti è permesso utilizzare '5'.
HyperNeutrino,

@KSmarts significa solo che se hai una tabella codici non standard, questi personaggi si spostano su quella tabella codici. Puoi ancora usare il loro punto di codice come parte del tuo programma.
Stephen,

3

Pyke , 133 144 byte

? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA

Provalo online!

Un orribile pasticcio di codice che può quasi certamente essere abbreviato ... Lo costruisce un carattere alla volta.

? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point
00q}}}XEj - Construct 64 by doing `((0==0)*2*2*2)**2` and then eval, getting the "@" character and store it in `j`
TX}G_E - Get "h" using `@` by looking it up in the alphabet
\E\L\LkJ - "hELL"
jRT}}XRGREkJ - "hELLo"
jR 00q}R? B_RE  - ","
\ \wkJ - "hELLo, w"
jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD"
jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!"
jRT}}RG_RE00q}}RAA - "Hello, World!"

2

dc , 164 162 byte

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAI*PL?P

Provalo online!

C'è probabilmente un approccio migliore / più interessante. Ho provato a usare il trucco ASCII + 256 che dcha, ma che genera anche caratteri aggiuntivi (anche se non sono in stampa), e una volta arrivato a 'o', il 111 meravigliosamente perfetto, ho riscontrato problemi anche ottenendo un valore di 111+ (multiplo di 256) considerato in modo chiaro. Quindi, ecco una soluzione abbastanza semplice (anche se golfizzata dove possibile):

Nel dc , zè un comando che spinge la profondità della pila sulla pila. Ciò significa che possiamo usarlo come incremento. Questo è il modo in cui creo la maggior parte dei miei valori ASCII per questa sfida (stampata con P), che spingo sugli stack nominati con Se pop-up sullo stack principale con L.

dcconsente di utilizzare i valori esadecimali AF anche quando la radice di input è decimale (impostazione predefinita). Fortunatamente, la nostra prima lettera, 72, è un multiplo di 12, quindi salvo un byte o due qui moltiplicando 6 * 12 e stampando immediatamente ( zzzzzzzC*P). La mia versione da 164 byte ha usato la moltiplicazione all'inizio per ottenere 72 ('H'), che era leggermente intelligente ma un blocco da un tentativo precedente e uno spreco di byte. Ora, inizio incrementando e salvando lo spazio, il punto esclamativo e la virgola, che sono fuori servizio e pertanto non possono ancora essere stampati. Successivamente, arrivo alla 'H', che stampo immediatamente, prima di arrivare alla 'W', che devo salvare per dopo.

Semplicemente stampo quando premo 'e', ​​quindi incremento fino a 'l'. Ne stampo due e ne salvo uno. Quando arrivo a 'o', ho pensato prima che avrei dovuto salvarne uno per dopo, ma è tutto sorta di in ordine a questo punto. Stampo una 'o', recupero la virgola, lo spazio e la 'W' da prima, e ora sono tornato a 'o'. Lo stampo e ne incremento alcuni fino al valore più alto necessario, 'r' (114), che stampo prima di caricare e stampare la 'l' che ho nascosto prima.

Quasi fatto! 'd' è il valore ASCII 100, che si ottiene facilmente moltiplicando 10 * 10 (meno byte rispetto a averlo memorizzato in precedenza e caricandolo ora). Il valore esadecimale Aè 10, così come il nostro input radix che possiamo recuperare con il comando I. Moltiplica quelli, stampa, quindi carica e stampa il nostro punto esclamativo da prima. Ciao mondo!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.