Come grande fan della serie TV Lost , sono sempre stato incuriosito dalla sequenza di numeri che appare ripetutamente negli episodi. Questi numeri sono:

$4, 8, 15, 16, 23, 42$ ( A104101 )

Usando qualsiasi linguaggio di programmazione, scrivi un codice che emetta questi numeri.

punteggio:

• Vince la risposta più breve

• L'output non deve contenere altri numeri o lettere. Puoi usare qualsiasi altro personaggio come separatore o addirittura nessun separatore.

• Non è possibile separare le cifre dello stesso numero. è una risposta valida, ma non lo è.$48\_15162342$$481\_5162342$

• Devi rispettare l'ordine.

• Se il tuo codice non contiene nessuno dei numeri della sequenza, riduci il punteggio del 30%. Questa regola ti consente di inserire le cifre separatamente. Per esempio:

  abcde1fg5h
  

  È un candidato valido perché la risposta non contiene il numero , ma solo le sue cifre. Tuttavia, qualsiasi o invaliderà il bonus.$15$$4$$8$

• Se il codice non contiene alcuna cifra, riduci il punteggio del 50%. Altri personaggi come , o sono ancora validi per questo bonus.$¹$$²$$³$

Perso , 29 27/2 = 13,5 byte

%?\>>>>>>>>>>
>>\"*"@"

Provalo online! o verifica che sia deterministico

Sembrava la lingua giusta da usare.

Spiegazione:

Lost è un linguaggio 2D in cui il puntatore inizia ovunque , andando in qualsiasi direzione. Questo generalmente porta a un doppio controllo che il puntatore non è entrato in una sezione in anticipo.

...>>>>>>>>>>  These arrows filter all pointers that appear on the top line
.............  Or going vertically


%............  This flips the flag so that the program can end
.............  This stops premature termination

.?\..........  Clear the stack by skipping if a value popped from the stack is positive
.............  When the stack is empty, the \ directs the pointer down

.............  The \ directs the pointer right
..\"*"..  The string literal pushes all the Lost values to the stack

..\..........  The @ terminates the program if the % flag is switched
>>\........@.  Otherwise it clears the stack and repeats

.............  The quote here is to prevent the pointer getting stuck
............"  This happens when the pointer starts between the other quotes

Gelatina , 7/2 = 3,5 byte

“ƲÞIȥ’Ḥ

Stampa i numeri senza separatore, ovvero l'intero $4815162342$ .

Provalo online!

Come funziona

“ƲÞIȥ’è letterale integer base-250 base intera.
Ʋ, Þ, I, E ȥhanno (1-based) indici $154$ , $21$ , $74$ , e $171$ nella tabella codici di gelatina, in modo che codificano l'intero $250^3\cdot154+250^2\cdot21+250\cdot74+171=2407581171$ .

Infine, Ḥ(unhalve) raddoppia il numero intero, producendo $2\cdot2407581171=4815162342$ .

È necessario raddoppiare, poiché la codifica dell'output porta direttamente a “¡9)Ƙ[’, che contiene una cifra.

Neim , 6 5 byte, 3 2,5 punti

Jσς§A

Spiegazione:

J     Push 48
 σ    Push 15
  ς   Push 16
   §  Push 23
    A Push 42
      Implicitly join the contents 
      of the stack together and print

Provalo online!

05AB1E , punteggio: 10 9 7 byte / 2 = 3,5

•‘o]Ê•·

Provalo online.

O alternativa a 7 byte :

•’µ[%•R

Provalo online.

Entrambi generano il numero intero 4815162342.

Spiegazione:

•‘o]Ê•     # Compressed integer 2407581171
      ·    # Doubled

•’µ[%•     # Compressed integer 2432615184
      R    # Reversed

Vedi questo mio suggerimento 05AB1E (sezione Come comprimere numeri interi di grandi dimensioni? ) Per capire perché •‘o]Ê•è 2407581171ed •’µ[%•è 2432615184.

9 byte vecchi rispondono emettendo l'elenco [4,8,15,16,23,42]:

•ΓƒÇ²•т;в

-1 byte (e quindi punteggio -0,5) grazie a @Emigna .

Più lungo dell'altra risposta 05AB1E , ma questo restituisce l'elenco [4,8,15,16,23,42]invece dell'intero 4815162342.

Provalo online.

Spiegazione:

•ΓƒÇ²•       # Compressed integer 1301916192
      т;     # Integer 50 (100 halved)
        в    # Convert the first integer to Base-50 (arbitrary): [4,8,15,16,23,42]

Vedi questo mio suggerimento 05AB1E (sezioni Come comprimere numeri interi grandi? E Come comprimere liste di numeri interi? ) Per capire perché •ΓƒÇ²•è 1301916192ed •ΓƒÇ²•50вè [4,8,15,16,23,42].

JavaScript (ES7), 34/2 = 17 byte

_=>eval(atob`NjUwNTgxMDErNDEqKjY`)

Provalo online!

Questo decodifica e valuta l'espressione "65058101+41**6", che non contiene alcuna cifra una volta codificata in base-64.

JavaScript (ES6), 13 byte

Soluzione ovvia noiosa.

_=>4815162342

Provalo online!

Python 3 , 25 byte, 12,5 punti

print(*map(ord,'ዏٗ*'))

Provalo online!

𩦦 （髒, ⿰ 馬 葬）, 𧨦 （謚, ⿰ 言 ⿱⿵ 八一 皿） costano 4 byte, ma U + 0657 costa solo 2 byte ...

Python 3 , 29 byte, 14,5 punti

print(ord('𩦦')*ord('湡'))

Provalo online!

𩦦 （⿰ 馬 葬） è il carattere variante di 髒 che significa "sporco". 湡 è il nome di un fiume. E non hanno nulla a che fare con questa domanda, come ho conosciuto.

Brain-Flak , 52/2 == 26 byte

(((((((((()()()())){})){}[()])())[]()()())){}[[]]())

Provalo online!

Java 8, punteggio: 12 11,9 (70% di 17 byte)

v->767*6277917L+3

-0,1 punteggio grazie a @RickHitchcock .

Provalo online.

Spiegazione:

v->               // Method with empty unused parameter and long return-type
  767             //  767
     *6277917L    //  multiplied by 6277917 (as long)
              +3  //  And then 3 is added

Vecchia risposta con un punteggio di: 12 (50% di 24 byte):

v->(long)''*'Ⓥ'*'䧶'

Contiene un carattere non stampabile 0x1B.

Provalo online.

Spiegazione:

v->                   // Method with empty unused parameter and long return-type
  (long)              //  Cast the character (and therefore the result) to a long
        ''            //  27
           *'Ⓥ'       //  Multiplied by 9419
                *'䧶'  //  Multiplied by 18934

In Java, i caratteri possono essere autoboxati in numeri interi che mantengono il loro valore unicode. Sfortunatamente, il massimo Unicode supportato per i personaggi è 65,535, quindi non posso usare solo due caratteri per moltiplicare (poiché i due numeri più grandi che dividono il previsto 4,815,162,342sono 56,802e 84,771, dove 84,771purtroppo supera il massimo 65,535.
Inoltre, poiché la dimensione massima di un intè 32 ² -1 ( 2,147,483,647) e il risultato 4,815,162,342è maggiore di quello, è richiesto un cast esplicito a long, che può contenere fino a 64 ² -1 ( 9,223,372,036,854,775,807).

La risposta noiosa sarebbe stata di 14 byte senza alcun bonus:

v->4815162341L

Provalo online.

R, 18x0,7 = 12,6 punti

cat(9*2*267509019)

Abbastanza autoesplicativo, fa solo un po 'di aritmetica evitando i numeri in questione.

7 , 10 byte, 27 caratteri

115160723426754314105574033

Provalo online!

La rappresentazione compatta di questo programma su disco è ( xxdformato):

00000000: 269c 3a71 6f63 308b 7c0d                 &.:qoc0.|.

Spiegazione

Abbiamo già visto questa sequenza di numeri in Automate Saving the World , che riguardava la stampa dei numeri a intervalli regolari, rendendolo interessante richiedendo l'uso di un linguaggio molto antico. Molte lingue più recenti possono avere i loro colpi di scena che rendono interessante questa sfida. _{(Sì, questo paragrafo, e in effetti il ​​motivo per cui ho iniziato a scrivere questa risposta, è effettivamente solo un modo per ottenere tutte le sfide correlate da mostrare insieme nella barra laterale; normalmente le persone lo fanno usando i commenti ma non ho abbastanza rappresentante .)}

La prima cosa da notare è che 7 è composto interamente da cifre, quindi è improbabile che i bonus qui funzionino (anche se se si considera il programma come una sequenza di ottetti, nessuno di essi corrisponde alle rappresentazioni ASCII di nessuno dei numeri originali , quindi potresti richiedere il bonus in tal senso). La prossima cosa da notare è che 7 ha comandi per ricreare la sequenza di comandi che probabilmente hanno prodotto un dato specifico; quindi potremmo forse interpretare i numeri persi 4815162342come una sezione di un programma 7 stesso?

La risposta è "non del tutto". La parte più problematica è quel secondo numero 8,. 7 programmi sono scritti in ottale; non esiste un numero come 8. Quindi l'inizio della stringa dovrà essere stampato in modo diverso.

La base del programma si basa quindi sul programma "Hello world" 7:

5431410557403
543141055          string literal
         7         separate data from code
          4        rearrange stack: {program's source}, empty element, {literal}
           0       escape {the literal}, appending it to {the empty element}
            3      output {the escaped literal}, pop {the program's source}

con l'essere letterale di escape in un linguaggio specifico del dominio che viene interpretato come segue:

5                  output format: US-TTY using pairs of digits in the string
 43                select character set: digits and common symbols
   14              "4"
     10            "8"
       55          forget the set output format

Dopo questo arriva un extra 3, che genera l'elemento stack rimanente (ed esce a causa dello stack rimanente insufficiente). Quell'elemento è specificato all'inizio del programma, e per evitare l'impareggiabile 6(che funziona un po 'come una parentesi di chiusura), lo generiamo usando il codice, piuttosto che scriverlo direttamente come dati. (Si noti che ci sono due 7caratteri impliciti all'inizio del programma, che è rilevante qui):

{77}115160723426
 7                 empty stack element
  7 11516          append "1151"
         0         append "6"
          723246   append "2324"

Questo produce il seguente letterale:

115162324
1                  set output format: literally as octal
 15162324          "15162324"

che viene stampato.

05AB1E , 6 * 0,7 = 4,2 byte

•1Z&ð“

Provalo online!

Stampa il numero non compresso da base-255

MASM 8088 Origine assembly, (93 byte - 50%) = 46,5 byte

Non usare numeri o la sequenza nella fonte:

MOV AH,'P'-'G'
LEA DX,L
INT '!'
RET
T EQU '-'-'+'
L DW 'ph'/T,'jb'/T,'lb'/T,'fd'/T,'dh'/T,'$'

Produzione:

A>LOST.COM
4815162342

Carbone , 13 byte / 2 = 6.5

ＩＥTPIHA.⁻⁸⁸℅ι

Provalo online! Il collegamento è alla versione dettagliata del codice. Funziona sottraendo i codici ASCII della stringa TPIHA.da 88 e eseguendo il casting in stringa.

Aheui (esotopo) , 45 byte (15 caratteri) * 0,5 = 22,5 punti

반밤밪박밭빠따받발따밣뱣히망어

Provalo online!

Spiegazione:

Vedi anche questo; Riferimento Aheui ( inglese )

Aheui program starts with default stack '아'(or none)

반: push 2, move cursor right by 1(→).
밤: push 4, →
밪: push 3, →
박: push 2, →
밭: push 4, →
빠: dup, →
따: pop 2, push mul result(16).
받: push 3, →
발: push 5, →
따: pop 2, push mul result(15).
밣: push 8, →
뱣: push 4, move cursor right by 2(→→).
히: end.
망: pop 1, print, → (if stack is empty, move cursor left by 1.)
어: move cursor left by 1(←).

Notare che ㅁ (istruzioni di stampa) sposta il cursore in direzione inversa se lo stack (o la coda) è vuoto.

Perl 5 , 16 byte - 30% = 11.2

say 0x5FAB2EA2*3

Provalo online!

PowerShell , 12 byte * 0,7 = 8.4

0x5FAB2EA2*3

Provalo online!

"Porta" della risposta di Xcali per avere una risposta Powershell migliore.

naz , 46 byte, punteggio 32,2

2a2a1o2m1o7s1o5m1o2s2s1o6m1o2s2s1o1a1o1a1o2s1o

Invia semplicemente ogni cifra in 4815162342una alla volta.

JavaScript, 143 byte (non sono sicuro di come segnare)

(g=`${2*2}`)=>g.repeat(6).replace(/(.)/g,(m,p,i,k='')=>
  (k=m*[g-3,g-2,g,g,+g+2,g*3-1][i]
  ,RegExp(`${g-2}|${g}`).test(i)?k-1:i==+g+1?k-(g/2):k))

Provalo online!

Inizia con sei 4, moltiplica, aggiungi, sottrai da, a, da 4per derivare l'output.

PHP, 35/2 = 17.5

<?=zzzzzzzzzzzzzzz^NVBVKOVKLVHIVNH;

un approccio digitale: 40 * .7 = 28

<?=2+2,_,5+3,_,17-2,_,17-1,_,17+6,_,7*6;

nessuna cifra, nessuna stringa: 68/2 = 34

<?=$p++,!$p++,$p+=$p,_,$p+=$p,_,~-$q=$p+$p,_,$q,_,--$p+$q,_,$p*~-$p;

Provali online .

JavaScript (SpiderMonkey), 67 byte / 2 = 33,5 60 byte / 2 = 30 58 byte / 2 = 29 48 byte / 2 = 24

-7 byte / 3,5 , -2 byte / 1 per gentile concessione di @JoKing, -10 byte / 5 per gentile concessione di @tsh

print(a=-~-~-~-~[],a+=a,b=a+~-a,a+a,a+b,--b+b+b)

Provalo online!

APL (Dyalog Unicode), 18/2 = 9 byte

×/⎕UCS'𩦦湡'

Solo noiosa moltiplicazione dei vecchi personaggi.

Provalo online!

JavaScript (ES6), 16 * 0,7 = 11,2 byte

_=>767*6277917+3

Emette le cifre senza delimitatori.

Provalo online!

Spazio bianco , punteggio: 49 41 byte / 2 = 20,5

[S S S T    S S S T T   T   T   T   S S S S S S S T T   S S S T S T T   T   T   T   S S T   T   S N
_Push_4815162342][T N
S T _Print_number]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Pseudo-codice:

Integer i = 4815162342
Print i as number to STDOUT

Spiegazione:

Negli spazi bianchi, un numero viene inserito come segue:

• S: Abilita la manipolazione dello stack
• S: Premere il numero
• S/ T: Rispettivamente positivo / negativo
• Alcuni T/ Sseguiti da un singolo N: decimale come binario, dove Tè 1 ed Sè 0

Dopodiché viene semplicemente stampato con TNST:

• TN: Abilita I / O
• S: Emette la parte superiore dello stack
• T: Come numero

F #, 45 byte = 22,5 punti

Solo un ciclo run-of-the-mill forche stampa le cifre:

for c in"DHOPWj"do printf"%d"(int c-int '@')

Quanto sopra è un programma completo che può essere compilato in un eseguibile.

In un REPL (ciclo read-eval-print), ad esempio FSI (F # Interactive), funzionerà la seguente versione più breve, poiché REPL produrrà una rappresentazione dell'espressione valutata; ha 35 byte = 17,5 punti:

[for c in"DHOPWj"->int c-int '@'];;

Pyke , 3 punti

77 91 f8 86 98 06

Provalo qui!

Il primo byte segnala di leggere in base 128 fino a quando non viene impostato un byte senza il bit alto.

Infine, 32 viene sottratto dal risultato (per motivi storici).

Ciò consente la generazione di grandi numeri in quantità molto ridotte di spazio

MathGolf , 7 byte * 0,5 = 3,5

ÿ≤┼ÇÅ$∞

Provalo online!

Spiegazione

Si noti che questo codice non funziona ancora su TIO. Di recente ho apportato alcune modifiche a MathGolf, inclusa l'aggiunta $dell'operatore. Una volta che viene portato su TIO, puoi eseguirlo lì, quindi farò un aggiornamento a questa risposta. Funziona perfettamente nel terminale

ÿ≤┼ÇÅ     Push "≤┼ÇÅ"
     $    pop(a), push ord(a) (pushes 2407581171)
      ∞   pop a, push 2*a

Uso il fatto che MathGolf abbia valori letterali di 1 byte per la creazione di stringhe fino alla lunghezza 4. Se avessi voluto convertire l'intero numero da una stringa di base 256, avrei dovuto usarne due "e la stringa sarebbe stata 5 personaggi. In questo modo, salvo 2 byte, ma perdo un byte avendo l'operatore di raddoppio alla fine.

Python 3 34 punti

b=len("  ");c=b*b;d=c*b;e=d*b;g=e+d-b//b;print(c,d,e-b//b,e,g,g*b-c)

Python 3 , 44 38 19 18,5 byte

-6 byte grazie a @Jo King
-50% byte grazie a @ouflak per la segnalazione del bonus del 50%
-1 byte grazie a @Dennis

for i in'밗ɯ*':print(ord(i),end='')

Provalo online!

Japt, 10 9 byte / 2 = 4.5

"0¢*"mc

Provalo

Befunge-98 (FBBI) , 15 byte / 2 = 7,5 punti

"*H/!k-"*.*+..@

Provalo online!

Spiegazione:

Spingi prima i valori ASCII dei caratteri '* + H /! K- (42, 72, 47, 33, 107, 45) in questo ordine nello stack. Quindi calcola$4815 = 45 \cdot 107$ e $1623 = 33\cdot 47+72$e output.