Figura e terra


32

figura e terra
Fonte: Wikipedia

Per questa sfida, dovresti scrivere due programmi che ricordano la figura e il terreno dell'immagine sopra, in modo tale che uno di essi stampi figuree l'altro stampi ground. In particolare:

  1. Scrivi un programma che non accetta input e stampa la stringa figure. Gli unici spazi bianchi consentiti nel tuo programma sono spazi (punto codice 0x20) e newline (ritorni a capo, 0x0D, avanzamenti riga, 0x0A o una combinazione di entrambi).
  2. Ignorando le nuove righe, il numero di caratteri spaziali (punto di codice 0x20) e caratteri non spaziali deve essere lo stesso. Ad esempio, questo sarebbe un programma valido (in un linguaggio ipotetico):

    ab c 
       d
    e f
    

    Si noti che c'è uno spazio finale sulla prima riga.

  3. Se si scambia il n ° carattere spazio con il n ° carattere non spazio bianco, il programma deve stampare ground, invece. Per l'esempio sopra il programma sarebbe simile al seguente:

      a b
    cde 
     f 
    

    Si noti che ci sono spazi finali sulla seconda e terza riga.

Sia la cifra e le terra soluzioni dovrebbero essere programmi completi nella stessa lingua, che stampare su STDOUT. In entrambi i casi è possibile stampare una nuova riga finale finale opzionale. È possibile produrre tutto ciò che si desidera su STDERR, purché STDOUT sia corretto.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

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

Helper Script

È possibile utilizzare questo script CJam per convertire tra un programma di figura e di terra . Basta incollare uno dei due nel campo Input ed eseguire il programma. Ti dirà anche se il numero di spazi e non spazi non corrisponde.

Classifica

Risposte:


20

Gelatina , 20 byte

figura

“¦ĠȮ“©ụd» Ṃ         

Nove spazi finali. Provalo online!

Terra

         “ ¦ĠȮ“©ụd»Ṃ

Nessuno spazio finale. Provalo online!

Come funziona

Innanzitutto, nota che gli spazi non sono atomi, quindi i caratteri di spazio al di fuori dei valori letterali delle stringhe non influiscono in alcun modo sul programma.

I letterali di stringa usano la compressione di stringhe incorporata basata su dizionario di Jelly per produrre le parole desiderate. Una stringa compressa letterale inizia con , termina con »e utilizza internamente per creare una matrice di stringhe.

Nel programma di figura , “¦ĠȮ“©ụd»produce la coppia di stringhe ("figura", "terra") e l'atomo seleziona il minimo lessicografico, ovvero "figura" .

Nel programma di terra, “ ¦ĠȮ“©ụd»restituisce invece la coppia di stringhe ("logicallyAbacs", "ground") . Il minimo lessicografico è ora "macinato" , che seleziona debitamente.

In entrambi i casi, l'interprete stampa automaticamente l'ultimo valore restituito, ovvero il minimo selezionato, su STDOUT.


14

Python 2, 53 byte

Sostituisci ·con spazio in entrambe le risposte:

····················
print'······figureground'[6:12]#

Stampe figure.

print'figureground'[
······6:12]#····················

Stampe ground.


14

05AB1E , 15 14 byte

figura

 'ŠÂ,'í¶      

Provalo online!

Terra

'       ŠÂ,'í¶

Provalo online!

Utilizza la codifica CP-1252 . Nota gli spazi finali. Nel programma Figura , è un programma normale senza errori. Decomprime le seguenti parole:

'ŠÂ  ->  figure
'í¶  ->  ground

La virgola stampa si apre e stampa la figureparola con una nuova riga. Poiché qualcosa è stato stampato, la parte superiore della pila non viene più stampata.

Nel programma di terra , ci sono alcuni errori che è conveniente in questo caso. La seguente parte:

'<space>

spinge un personaggio spaziale in cima alla pila. La Šruota la pila, che ha un arit'a 3 . C'è solo un elemento nello stack e nessun input, quindi questo dà un'eccezione, cancellando lo stack. La Âbiforcazione della parte superiore della pila, ma questa ha la stessa storia dell'operatore di rotazione. Quindi in pratica il ,comando non stampa nulla.

Ciò significa che il programma produrrà comunque la parte superiore dello stack che è 'í¶. Risultato in ground.


9

Retina , 31 byte

Figura:

|       
figura
 | terra
      

Terra:

 | figura

|       
terra

Figura e terra . Entrambi i programmi richiedono che STDIN sia lasciato vuoto per essere valido per figure o programmi a terra.


9

Pyth, 30 byte

figura

"figure" "ground              

14 spazi finali.

Test

Terra

Nessuno spazio finale

        "       figure""ground

Test

Come funziona

Piuttosto utile, uno spazio sopprime la stampa in Pyth, mentre i letterali di stringhe senza chiusura " sono implicitamente chiusi.

Il primo programma è quindi composto da due stringhe "figure"e "ground ". La prima stringa viene implicitamente stampata e la stampa della seconda viene soppressa, il che significa che figureviene stampata.

Il secondo programma è composto da due stringhe " figure"e "ground". La stampa della prima è soppressa e la seconda è implicitamente stampata, il che significa che groundè appena stampata.


6

MATL , 37 byte

Primo programma

'figure'         
%x'ground'         

Ogni riga ha 9 spazi finali.

Provalo online!

Secondo programma

    'figure'%
      x'ground'

Non ci sono spazi di valutazione qui.

Provalo online!

Spiegazione

Niente di terribile fantasia ...

  • Gli spazi e le nuove righe tra le istruzioni vengono ignorati da MATL.
  • % è il simbolo del commento, che ignora il resto della riga.
  • x elimina la parte superiore dello stack.
  • La pila viene implicitamente stampata alla fine del programma.

6

Java, 180 byte

Sostituisci .con spazio.

Stampa "figura":

class
A{public
static
void
main(String[]a){System.out.println(
//"ground"
//
.....
........
......
....
...................................
..
........
..........
....
"figure");}}

Stampa "terra":

.....
........
......
....
...................................
..........
..
class
A{public
static
void
main(String[]a){System.out.println(
//
"ground"
//"figure"
);}}
............

5

Befunge, 54 byte

Figura ( Provalo online! )

#v "erugif" v>
      : #, _ @>         
"Dnuorg"

Dieci spazi finali sulla seconda riga.

Terra ( provalo online! )

  # v "erugif" v 
>: #, _ @> "dnuorg"
        

Uno spazio finale sulla prima riga e otto spazi sulla terza riga.


4

Mathematica, 50 34 byte

Utilizza un ambiente REPL. (L'aggiunta di un Print[]wrapper con un numero uguale di spazi aumenterebbe il conteggio dei byte di 14.) I due programmi sono

01figure+0 1ground                

(con 16 spazi finali) e

          0       1figure+01ground

La chiave qui è che Mathematica tratta la concatenazione delle cifre senza spazi come un singolo numero, ma gli spazi intermedi vengono interpretati come moltiplicazione vicina, così come la concatenazione di numeri e nomi di variabili arbitrarie. Quindi la prima espressione valuta 1*figure+0*1*ground, che è figure; la seconda espressione valuta 0*1*figure+1*ground, che è ground.


4

PHP, 44 42 byte

figura: (16 spazi finali, 5 spazi tra figura &;)

echo''?ground:figure     ;                 

terra: (20 spazi principali)

                     echo' '?ground:figure;

Abbastanza semplice davvero, funziona perché ''è falso ed ' 'è vero. Usa come:

php -r "echo''?ground:figure     ;                "
php -r "                    echo' '?ground:figure;"

modifica: 2 byte ovvi retrospettivamente salvati grazie a Martin Ender


3

Haskell, 96 94 88 82 77 byte

Primo programma, stampa "figure":

main              =          putStr$idid"ground"
idid    _          ="figure"

Secondo programma, stampa "ground":

    main=putStr$id id"ground"                   
    idid _="figure"         

Chiama una delle due funzioni costanti con nomi diversi


3

Haskell, 88 65 byte

main=putStr
...........--
.."figure"..........
--"ground"........

e

...........
main=putStr..
--........"figure"--
.........."ground"

.indica uno spazio. Solo qualche commento di riga (-> --) giocoleria.


3

Python 2, 52 byte

........................
print"figure"
an
d
"ground"

.s indicano spazi. Le ultime tre righe sono suddivise per errore senza avere un SyntaxErrorche impedirebbe in primo luogo l'esecuzione del codice.

La versione ground utilizza solo andper stampare la seconda stringa.


Tentativi alternativi (più lunghi):

.......
print(#"ground")#
"figure")...................


print"figure"""and"ground"
.............
.............

3

JavaScript (ES6), 56 byte

alert('figure'
                //&&'ground'
           )
              
alert('figure'//            
&&'ground') 

La figura non ha spazi finali.


Conto 56 byte per ogni programma, a meno che le newline non contino. Dubito che diventerà più breve.
ETHproductions

@ETHproductions Ugh, ecco cosa succede quando conti i byte manualmente :-(
Neil

2

Rail , 56 byte

figura

$'main'
 -[figure]o                
-          [ground]o

Ci sono 16 spazi finali sulla seconda riga. Il programma termina con un errore.

Provalo online!

Terra

       
$ 'main' - [figure] o
 - [terra] o         

Ci sono 7 spazi sulla prima riga e 9 spazi finali sull'ultima riga. Questo programma termina anche con un errore.

Provalo online!

Spiegazione

Rail cerca una linea che inizia con (notazione regex) \$.*'main'per trovare un punto di ingresso. Il treno (puntatore istruzioni) inizia quindi dal $movimento sud-est. Le cose che non sono raggiungibili dal treno possono essere completamente ignorate per il programma. Ciò include qualsiasi cosa sulla stessa riga del punto di ingresso. Dal momento che il -sud-est del $treno gira immediatamente a est, entrambi i programmi si riducono semplicemente a:

 -[figure]o
 -[ground]o

[...]indica una stringa letterale e la ostampa. Normalmente, hai bisogno di un #per terminare il binario, ma se lo ometti, il programma termina comunque (ma si lamenta su STDERR che il treno si è schiantato).


2

> <> , 39 byte

Usando ·per rappresentare gli spazi.

figura

v·
"·dnuo
e·
r·
u·
g··
i··
f···
"·
>·o·

Provalo online!

Terra

·v
·"····
·d
·n
·u
·oe
·ru
·gif
·"
·>·o

Provalo online!

Entrambi i programmi terminano con un errore.

Spiegazione

Scrivendo il codice in verticale, sono stato in grado di riutilizzare la ge rtra le due soluzioni, nonché le virgolette e la >eo per il ciclo di output.

In entrambi i casi, l'unico bit che viene eseguito è la colonna sotto la v, che spinge le lettere della parola richiesta nello stack in ordine inverso. Quindi >reindirizza il puntatore dell'istruzione verso destra, dove scorre attraverso il o, stampando i caratteri fino a quando la pila è vuota.


Ho appena iniziato a lavorare sulla mia versione> <>, poi mi sono imbattuto nella tua. Mi piace molto l'idea che tu lavori in verticale (la mia è molto "normale").
Pellicano verde acqua,

@Tealpelican Non ho pensato a questo fino a quando non ho elaborato la risposta Fission. Prima di allora la mia migliore soluzione <> era di 42 byte: !__|"druong">o<"figure"(dove _sono gli spazi e gli spazi rimanenti vanno semplicemente alla fine della linea).
Martin Ender,

La mia versione attuale più corta è questa; ## "de nr uu og ri GF"> o! ~ ~! <## Che abbastanza divertente è anche 42 byte! Le mie versioni precedenti avevano un controllo degli errori ma potevano ridurre solo a 53 byte.
Pellicano alzavola,

2

Fissione , 37 byte

Usando ·per rappresentare gli spazi.

figura

D·
"···
f··
i··
g·
u·
r·
e·ound
"·
;·

Provalo online!

Terra

·D
·"fi
·gu
·re
·o
·u
·n
·d····
·"
·;

Provalo online!

Spiegazione

Funziona praticamente come mia risposta <> (anche se in realtà l'ho trovata per prima). Le uniche differenze sono che "stampa immediatamente i personaggi in Fissione, motivo per cui le parole non sono scritte sottosopra e perché dobbiamo solo terminare il programma ;alla fine.


1

reticolare, 46 byte

                      "ground""figure"" "?$$o;

Provalo online! Questo stampaground .

"ground""figure"""?$$o                 ;      

Provalo online! Questo stampafigure .

terra

Codice pertinente:

"ground""figure"" "?$$o;
................          push these two strings
                " "?$     pop " " off (since " " is truthy, `?` executes `$`)
                     $    pop TOS ("figure")
                      o;  output and terminate

figura

Codice pertinente:

"ground""figure"""?$$o;
................         push these two strings
                ""?$     doesn't activate
                    $    pop ""
                     o;  output and terminate

1

Brian & Chuck , 55 53 byte

figura

erugif?dnuorg             
}<.<.<.<.<.<.             

Ci sono 13 spazi finali su ogni riga.

Provalo online!

Terra

             erugif?dnuorg
             }<.<.<.<.<.<.

Provalo online!

Spiegazione

Ah, è passato un po 'di tempo dall'ultima volta che ho usato Brian e Chuck. Come breve promemoria, Brian e Chuck sono due istanze simili a Brainfuck, che usano il codice sorgente dell'altro come nastro. Solo Chuck può usare il comando di stampa ., ?passa tra le due istanze in modo condizionale ed }è una specie di simile[>] in Brainfuck. I comandi sconosciuti vengono semplicemente ignorati.

Poiché gli spazi all'inizio dei programmi vengono ignorati, i due programmi sono quasi identici. L'unica differenza deriva dal fatto che dopo il comando di commutazione ?, il puntatore dell'istruzione si sposta prima di eseguire il comando successivo. Quindi, il primo comando sul nastro di Chuck viene sempre ignorato. Quindi l'unica vera differenza è che il programma di terra esegue il }mentre il programma figure no. Quindi ecco come funziona il codice:

?   Switch control to Chuck.
}   GROUND PROGRAM ONLY: Move the tape head on Brian to the end of the tape.
<.  Move the tape head left and print the character there.
... Do the same another five times to print the remainder of the string.

0

WinDbg, 74 byte

Terra

                      ea2000000"      groundfigure";;;da       2000006  L6

figura

ea2000000"groundfigure          ";;;da                  2000006       L6  

La figura ha 2 spazi finali. Sento che almeno 2 o 4 byte dovrebbero essere giocabili a golf ...

Funziona scrivendo una stringa in memoria e mostrando 6 caratteri da essa. I caratteri nella stringa vengono riorganizzati in modo che i caratteri visualizzati cambino tra i programmi:

* Ground:
ea 2000000 "      groundfigure";     * Write string "      groundfigure" starting at 2000000
;                                    * No-op
;                                    * No-op
da 2000006 L6                        * Print 6 ascii chars, from 2000006, ie- ground

* Figure:
ea 2000000 "groundfigure          "; * Write string "groundfigure          " to memory
;                                    * No-op
;                                    * No-op
da 2000006 L6                        * Print 6 ascii chars, ie- figure

Produzione:

0:000>                       ea2000000"      groundfigure";;;da       2000006  L6
02000006  "ground"
0:000> ea2000000"groundfigure          ";;;da                  2000006       L6  
02000006  "figure"
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.