Scrivere uno script che funzioni correttamente quando è presente una riga vuota nel flusso della logica del programma, ma interrompe o provoca comportamenti imprevisti quando viene rimossa quella riga.

Evita scappatoie standard e risposte stupide. Il tuo programma dovrebbe fare qualcosa di "utile", anche se tutto ciò che fa è aggiungere alcuni numeri interi.

La rimozione di una riga vuota da una stringa su più righe non conta, a meno che l'output previsto da quella stringa su più righe non debba tecnicamente cambiare (ad es. Se si rimuovono tutte le righe vuote corrispondenti ^$).

Non è nemmeno permesso lo sciocco degli spazi bianchi; non fare cose strane con ritorni a capo, tabulazioni, spazi, ecc.

Javascript

Apre un popup di avviso con "Ciao, mondo!" se esiste una riga vuota, altrimenti avvisa "0".

(function(){
    alert(~(arguments.callee+[]).indexOf('\n\n') && "Hello, World!");

})();

dimostrazione

Spiegazione:

arguments.callee è un riferimento alla funzione anonima autoeseguente.

L'aggiunta di un array vuoto ( []) lancia la funzione su una stringa, che fornisce il suo codice sorgente.

indexOfritorna -1se la stringa non viene trovata.

L'esecuzione di un'operazione bit a bit ( ~) comporta la -1trasformazione in 0, che è un valore di falso.

C

Questo magico programma a 8 palle funzionerà ancora senza la riga vuota, ma sarà un po 'più decisivo: nessuna delle risposte neutre apparirà mai nell'output.

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int main() {
  int x, t;
  char *quotes[] = {
        // Positive :-)
        "It is certain", "It is decidedly so", "Without a doubt", "Yes definitely", "You may rely on it",
        "As I see it, yes", "Most likely", "Outlook good", "Yes", "Signs point to yes",
        // Indifferent :-\

        "Reply hazy try again", "Ask again later", "Better not tell you now", "Cannot predict now", "Concentrate and ask again",
        // Negative :-(
        "Don't count on it", "My reply is no", "My sources say no", "Outlook not so good", "Very doubtful" };
  srandom(time(NULL)); // Initialize random number generator
  x = random() % (sizeof(quotes) / sizeof(char*)); // Choose a random outcome
  printf("The Magic Eight Ball says...\n%s\n",quotes[x]);
  return 0;
}

Spiegazione

Quando il parser C vede una barra rovesciata seguita da un carattere di nuova riga, ignora entrambi e considera la seconda riga come una continuazione della prima. Senza la riga vuota, le risposte "indifferenti" verranno trattate come parte del commento precedente.

Befunge-93

v
&
&
+
#

.
@

Il mio primo programma befunge :)

Legge due numeri dall'input e stampa la loro somma. Se si elimina la riga vuota, non stampa nulla.

Spiegazione:

vimposta una direzione verso il basso per l'esecuzione del codice
&legge un numero intero
+aggiunge i numeri insieme
#salta il comando successivo
.stampa un numero intero dallo stack
@termina il programma

Come scritto, #salta la riga vuota e continua .. Acquista quando elimini la riga vuota, .viene saltato.

Sembra che ci sia un simpatico interprete su http://befunge.aurlien.net/

Rubino / Shell

​​​​​​
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#!   The Amazing Integer Adder             !
#! Adds 1 and 1, and displays the result   !
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

p 1+1

Funziona bene se una nuova riga è in alto, altrimenti la prima riga di commento viene interpretata dalla shell come un shebang malformato.

Scala

case class IntWrapper(i: Int)

{
  val answer = (IntWrapper(0) /: (1 to 100)){(x, y) => IntWrapper(x.i + y)} // Add up ints
  println(s"Sum of wrapped integers is $answer")
}

Se si rimuove la riga vuota, non verrà stampato alcun output. Quale è per il meglio, poiché il tuo stack traboccerebbe se effettivamente chiamassi IntWrapper.

Questo è un caso angolare dell'inferenza di punto e virgola di Scala. Normalmente i newline ottengono un punto e virgola ogni volta che il codice risultante sarebbe valido. Tuttavia, gli sviluppatori Scala non volevano costringere le persone a usare parentesi egiziane , quindi è valido mettere le parentesi per una definizione di classe sulla riga immediatamente dopo - non viene aggiunto alcun punto e virgola, anche se si potrebbe essere. Tuttavia, una riga vuota separa le parentesi dalla definizione di classe. Con la riga vuota rimossa, il codice cambia da definizione di classe e blocco, a definizione di classe con un costruttore - e un costruttore ricorsivo in questo!

GolfScript

~{.@\%:

}do;

Calcola il GCD di due numeri interi diversi da zero. La rimozione della riga vuota interrompe il programma.

Provalo online.

Come funziona

Questa è un'implementazione GolfScript dell'algoritmo euclideo:

      # STACK: "15 24"
~     # Interpret the input string.
{     # STACK: 15 24
  .@  # Duplicate the topmost integer and rotate the other on top of both copies.
      # STACK: 24 24 15
  \   # Swap the topmost integers.
      # STACK: 24 15 24
  %   # Calculate the modulus.
      # STACK: 24 15
}do   # If the modulus is non-zero, repeat the loop.
;     # Discard the last modulus.

C'è solo un piccolo problema:

{}doestrae il modulo dallo stack per verificare se è vero, quindi deve essere duplicato alla fine del loop. Questo è normalmente realizzato da ., ma :\n\nha lo stesso effetto: memorizza l'elemento di stack più in alto nella variabile LF ( :\n), quindi invia il contenuto di quella variabile.

Sintassi del modello MediaWiki

Definisci modello: Foo as

{{{a

b|Uh-oh!}}}

In un'altra pagina,

{{Foo|a

b=Works!}}  <!-- outputs "Works!" -->

{{Foo|a


b=Works!}}  <!-- outputs "Uh-oh!" -->

{{Foo|a
b=Works!}}  <!-- outputs "Uh-oh!" -->

In MediaWiki, i nomi dei parametri possono contenere newline.

LaTeX (backref)

Il seguente codice LaTeX utilizza una citazione e la citazione contiene un elenco di pagine, in cui la voce è citata. Ecco la prima pagina. Il pacchetto hyperrefaggiunge anche collegamenti PDF, il riferimento indietro della pagina è rosso, il collegamento citazione è verde.

\documentclass{article}
\usepackage[colorlinks,pagebackref]{hyperref}
\begin{document}
Donald E. Knuth is the inventor of \TeX~\cite{knuth}.
\begin{thebibliography}{9}
\bibitem{knuth}
Donald E. Knuth: \textit{The \TeX book}; Addison Wesley, 1984.

\end{thebibliography}
\end{document}

Ma LaTeX non richiede la linea vuota, la linea vuota sembra superflua e l'esempio funzionerà ancora senza hyperrefe la linea vuota:

\documentclass{article}
\begin{document}
Donald E. Knuth is the inventor of \TeX~\cite{knuth}.
\begin{thebibliography}{9}
\bibitem{knuth}
Donald E. Knuth: \textit{The \TeX book}; Addison Wesley, 1984.
\end{thebibliography}
\end{document}

Ma i collegamenti e il riferimento posteriore sono spariti, quindi li reinseriamo:

\documentclass{article}
\usepackage[colorlinks,pagebackref]{hyperref}
\begin{document}
Donald E. Knuth is the inventor of \TeX~\cite{knuth}.
\begin{thebibliography}{9}
\bibitem{knuth}
Donald E. Knuth: \textit{The \TeX book}; Addison Wesley, 1984.
\end{thebibliography}
\end{document}

Ma ora l'esempio è rotto e non verrà più compilato :

Runaway argument?
 Donald E. Knuth: \textit {The \TeX book}; Addison Wesley, 1984. \end \ETC.
! File ended while scanning use of \BR@@bibitem.
<inserted text> 
                \par 
<*> knuth

?

Quello che è successo? Il pacchetto hyperref(o pacchetto più preciso backref, che viene caricato da hyperref) vuole ottenere alla fine della voce bibliografica per aggiungere la lista di riferimento posteriore. Ma la sintassi in LaTeX fornisce solo l'inizio della voce entro \bibitem, la fine può essere ovunque. In questo pacchetto di emergenzabackref è stata aggiunta una restrizione che \bibitemdeve terminare l'inserimento con una riga vuota. Quindi il pacchetto può essere ridefinito \bibitemper mettere i riferimenti posteriori alla fine della voce.

Poiché manca la riga vuota, TeX continua a cercarla, ma trova invece la fine del file ed emette il messaggio di errore.

C (semi-offuscato)

Questo piccolo programma prende un numero dalla riga di comando e calcola il suo fattoriale. Tuttavia, contiene anche funzionalità AI all'avanguardia per la verifica del runtime secondo cui vengono seguiti gli standard di codifica dell'azienda, incluso l'uso corretto di spazi bianchi e righe vuote. La rimozione di una riga vuota attiverà l'algoritmo per rifiutare il programma insufficientemente gestibile.

Nessuna continuazione di linea o trigrafia ovunque. Credo che sia valido ANSI C99.

A causa della matematica avanzata coinvolta, se compilate gcc, ricordatevi di usare -lm.

#include <setjmp.h>
#include <stdio.h>
#define max(x,y) ((x<y?y:x))
#define swap(x,y) ((x^=y,y^=x,x^=y))
#include <stdlib.h>
#include <math.h>
#define vfry(x,p,z,y,i) (!!y&((z##z##L##I##p##x##z##z)))
#define NDEBUG

/* 
 * Proper use of whitespace is essential!
 * Please do not remove any blank lines.
 */

const double E = 2.71828182845904523536;

int vrfy(double epsilon, int magic, const char *key, long int L) {
  /* You are not expected to understand this */
  double x=284.2891,u=2.34e56;
  while (rand()+magic*pow(epsilon,sin(x-E))!=log(u*L))
    x*=vrfy(1.0/epsilon,(int)u,&key[swap(L,magic)],L++);
  return u/lgamma(x);
}

int main(int argc, char *argv[]) {
  int N_=831293812; /* do not change, see Knuth 1987 */
  if (!vfry(E, N,_, "M=&;VT=I!9", 0xfe86ddcaL)) {
    fprintf(stderr, "Code standards violation detected!\n");
    abort();
  }
  if (argc < 2) {
    fprintf(stderr, "Usage: %s n\nComputes n!\n", argv[0]);
    exit(1);
  }
  int m=1, n=atoi(argv[1]), i;
  for (i=1; i <= n; i++)
    m *= i;
  printf("%d! = %d\n", n, m);
  return 0;
}

spoiler

La complicata vrfyfunzione non viene mai chiamata, ma piuttosto la vfrymacro dall'aspetto divertente . L'uso della funzione di concatenazione delle stringhe del preprocessore nasconde il fatto che stiamo davvero verificando la parità di __LINE__.

C

Questo programma funziona come previsto (come descritto nei commenti) a meno che non foo = 5;venga rimossa la riga vuota prima .

Purtroppo, ho riscontrato un errore quasi esattamente come questo nel codice di produzione una volta.

#include <stdio.h>

int main()
{
    int foo = 0;

    #define FROB(x) do {                                            \
        x++;                                                        \
        printf("%d\n", x);                                          \
    } while (0);                                                    \

    foo = 5;
    FROB(foo); /* prints 6 */
    FROB(foo); /* prints 7 */
    FROB(foo); /* prints 8 */

    return 0;
}

In questo esempio viene utilizzato il do { ... } while (0)linguaggio per creare un'istruzione multilinea in una macro (consultare https://stackoverflow.com/questions/257418/do-while-0-what-is-it-good-for ). Utilizza anche il carattere barra rovesciata per distribuire una #definelinea multipla, comodamente allineata ben nascosta alla vista. Tuttavia, fa anche due cose di tipo sbagliato:

• C'è un punto e virgola dopo while (0), mentre il linguaggio di solito lo omette
• C'è una barra rovesciata dopo l'ultima riga del file #define

Con questo in luogo, rimuovendo la riga vuota prima foo = 5;cause che una cessione ad essere eseguito dopo la printf, ma anche dopo ogni invocazione della FROBmacro. Di conseguenza, l'output dopo aver rimosso la riga vuota è:

1
6
6

C / C ++

int main(){

    return __LINE__ - 3;
}

Restituisce successo e può essere utilizzato come implementazione per true . Se viene rimossa la riga vuota, è possibile utilizzarla come implementazione per false .

PowerShell

Questa funzione aggiungerà due numeri.

function add ($a, $b) {
    $numbers = @($a `

            $b)
        $numbers| measure -sum| select -expand sum
}

La rimozione della riga vuota comporterà il fallimento della funzione con: Unexpected token '$b' in expression or statement.

Spiegazione

Gli elementi dell'array possono essere separati da newline e / o virgole. Inserire il carattere di continuazione della riga ( `) dopo $arichiede una nuova riga in più per separare $ae $b. In caso contrario, l'interprete visualizza il codice come $numbers = @($a $b)(nessun separatore di elementi).

TeX

\noindent\everypar{$\bullet$ hello }

world
\bye

Senza la riga vuota, "ciao" non viene stampato.

Spiegazione

TeX considera la riga vuota come un'interruzione di paragrafo e \everyparviene eseguita all'inizio di un nuovo paragrafo.

Giava

import java.util.Scanner;

public class BlankLine
{
    public static void main( String[] args )
    {
        //This calculates 2^ given number
        //if you remove blank line after the next line it will always print 1
        int x = new Throwable().getStackTrace()[0].getLineNumber();

        int y = new Throwable().getStackTrace()[0].getLineNumber() - x;
        System.out.println("Number:");
        Scanner scanner = new Scanner(System.in);
        int r = 1;
        int n = scanner.nextInt();

        for(int i = 0; i < n; i++){
            r *= y;
        }
        System.out.println("2^number: "+r);
    }
}

x è il numero di riga corrente, y è il numero di riga corrente - x. Se c'è una linea vuota tra loro il risultato è 2. Quindi il codice calcola 2 ^ numero.

Perl 5

print(<<""
Hello, World!

);

Questo codice viene stampato Hello, World!. La rimozione della riga vuota genera invece un errore di sintassi.

Spiegazione:

Sintassi here-doc di Perl per le stringhe multilinea consente una stringa di terminazione vuota. È persino esplicitamente documentato. La rimozione della riga vuota causa l'interpretazione della parentesi di chiusura (e tutto il resto fino alla riga vuota successiva, se presente) come parte della stringa, causando un errore di sintassi.

I messaggi di errore che ricevi sono in realtà abbastanza decenti, per una caratteristica di sintassi così strana. Se non ci sono righe vuote nel programma dopo la print(<<""riga, Perl dice semplicemente:

Impossibile trovare il terminatore di stringa "" da nessuna parte prima di EOF alla riga 1 di foo.pl.

Se non v'è una riga vuota alla fine del programma, si ottiene qualcosa di simile a questo, invece:

errore di sintassi alla riga 4 di foo.pl, a EOF
  (Potrebbe essere una stringa multi-linea in fuga << a partire dalla linea 1)
Esecuzione di foo.pl interrotta a causa di errori di compilazione.

partita

@echo off
setLocal enableDelayedExpansion
set NL=^


echo Hello!NL!World

Questo codice verrà emesso Helloe nella riga successiva World. Quando una o entrambe le linee vuote vengono rimosse, non viene emesso nulla.

C'è una spiegazione qui .

Rubino

La cancellazione della prima riga provocherà un errore:

line = IO.readlines($0).first.chomp
if line.empty?
puts 34+4
else 
raise "Please add a newline at the beginning of the program."
end 

Pitone

Non so se questo rientra nelle scappatoie standard, ho guardato l'elenco e non l'ho visto.

src = open(__file__, 'r')
code = src.readlines()
src.close()

if code[3] == '\n':
    print 'Hello World!'

L'esecuzione di questo regolarmente ritorna

Hello World!

Eseguendolo senza la riga vuota sulla riga 4, ovvero come di seguito:

src = open(
__file__, 'r')
code = src.readlines()
src.close()
if code[3] == '\n':
    print 'Hello World!'

non restituisce nulla.

Python 2.x

Questo programma genera il quinto carattere della stringa immessa.

import inspect

text = raw_input()
print 'Fifth character of the string:', text[inspect.getlineno(inspect.currentframe())]

Questo non è in alcun modo nascosto. Se rimuovi la riga vuota, viene indicato il quarto carattere e il sesto se ne aggiungi uno.

Tcl

Una funzione che aggiunge due numeri (e verifica se la nuova riga è stata eliminata):

proc add {a b} {
    if {[llength [split [info body add] \n]] < 5} {error "function has been modified"}

    return [expr $a+$b]
}

Non c'è niente da nascondere qui, fa quello che dice, quindi non sto rovinando la spiegazione. La funzione infoè un coltellino svizzero di introspezione (ciò che altre lingue chiamano riflessione). info bodyrestituisce il codice sorgente di una funzione (se non scritto in C o assembly).

Devo ammettere che questo mi ha lasciato perplesso fino a quando ho visto la soluzione javascript.

C

#include <stdio.h>


int main() {
    const char* a = "You love blank lines.";
    #define print_out(a) \

    printf("%s\n", a);
    a = "You don't seem to love blank lines";
    print_out(a);
    return 0;
}

Con la riga vuota, aè la variabile locale a e senza il parametro macro ...

Tecnicamente non è un problema di "codice", ma di server. Se questo viene inviato ad Apache da uno script CGI (che può essere generato con qualsiasi lingua tu voglia), invierà una risposta HTTP al client:

HTTP/1.x 200 OK 
Content-Type: text/html; charset=UTF-8

Hello world!

D'altra parte, questo fallirà perché manca lo spazio vuoto dopo l'intestazione.

HTTP/1.x 200 OK 
Content-Type: text/html; charset=UTF-8
Hello world!

JavaScript

La funzione whereamirisponde con la posizione della linea chiamante, relativa alla propria posizione nel codice sorgente.

console.log (whereami ()) //3 line(s)  before me 


function whereami () {
    var a=function a(e){try{to}catch(c){for(var d=c.stack.split("\n"),b=0;b<d.length&&!~d[b].indexOf("a");b++);return c.stack.split("\n")[b+~~e].match(/:(\d+)/)[1]-~~window.hasOwnProperty("__commandLineAPI")}},a1=a(1),i


    i= a(2)>a(1)+4?a(1):a(1)>a1+2?a1-1:a/a1



    return ((i=(a(2)<i?i-1:a(1)>i+3?a(2)-a(1)-1:a/1)) + " line(s) "   ) + (i<a(2)?" after":(i>=a(2)?" before":"confusing")) + " me";
}


console.log (whereami ()) //3 line(s)  after me

Se whereamiviene rimossa una riga vuota nella funzione. L'output è NaN line(s) confusing me. (L'aggiunta di linee non lo interrompe)

In realtà conta solo quante linee sono tra rispettivamente ila prima e l'ultima riga. Se rientrano in un determinato valore. La linea di riferimento è impostata su NaNcui né soddisfa NaN<callingLinené NaN>=callingLine. Ho provato a nasconderlo un po 'in espressioni ternarie illeggibili.

Perl

#!/usr/bin/perl

use strict;
use warnings;

open IN, "<".$0 or die "Did not find input files!";
while (<IN>) {
        m/blabla/ && ((<IN> =~ /\}/ && print "tra-la-la...\n") || print "ti-ri-li\n");

}
close IN;

Questo script perl leggerà il file di script e verificherà se dopo la riga contenente "blabla" è presente una parentesi quadra di chiusura.

Escript

A causa di un bug escriptnell'implementazione, l'escript valido deve essere lungo almeno tre righe e la prima riga deve essere shebang line o riga vuota. Quindi lo script seguente deve avere due righe vuote in cui la prima deve essere la prima:

main(_) -> io:format("Hello world!~n", []), halt().

O deve essere interrotto in due righe ma deve ancora avere la prima riga vuota.

main(_) ->
    io:format("Hello world!~n", []), halt().

Altrimenti otterrai

escript: Premature end of file reached

Rubino

print %q
2+2=

p(2+2)

Stampa 2+2=4, ma genera un errore di sintassi senza la terza riga vuota. %qconsente a qualsiasi carattere non di parola di fungere da delimitatore di stringa, anche il carattere di nuova riga. Quindi le prime tre righe di codice sono effettivamente equivalenti print %q"2+2="o semplici print "2+2=". Poiché il newline after 2+2=viene utilizzato come delimitatore di virgolette, non viene anche analizzato come delimitatore di riga , quindi è necessario un altro immediatamente successivo.

Insonnia (entrambe le versioni)!

Þyoo

â

Questo codice stampa un ~ (non chiedere perché, l'insonnia è strana). Se rimuovi la linea vuota, stampa invece un ÿ.

A proposito, quella prima lettera è una spina .

C ++

Questo è un trucco classico e piuttosto stupido. Saprai di cosa si tratta quando lo vedi, questo è qui solo per amor di completamento. Come tale, lo segnerò come una risposta wiki della comunità.

int main() {
    //This program won't work without the next line, why??/

    return 1;
}

Perché questo funziona

Incollalo in un file html e aprilo nel tuo browser. È piuttosto semplice, ma un po 'complicato perché richiede il numero di righe vuote nel documento e indicizza un array per chiamare una funzione che mostra un avviso.

<body>
<script>
[null, function(){alert("GIVE ME MY LINE BACK")}, function(){alert("2 + 2 = " + (2+2))}][document.body.innerHTML.split("\n\n").length]()

</script>
</body>

Questo è infrangere le regole al limite. Tecnicamente JavaScript non ha stringhe multilinea, che è l'unica ragione per cui funziona.

Poiché è possibile che si verifichi un errore di sintassi in un tag di script senza interferire con gli altri tag di script, questo mostra un risultato positivo solo se si verifica un errore nella pagina. L'errore impedisce l'attivazione del secondo avviso perché si trova nello stesso tag di script.

<body>
<script>
window.onerror=function(){
  alert("2 + 2 = " + (2+2));
}
</script>
<script>
var a = "\

";
alert("GIVE ME MY LINE BACK!");
</script>
</body>

Rubino

puts (% #{ARGV[0].to_i + ARGV[1].to_i}

)

Il segreto è che la newline è davvero una scheda, quindi una nuova riga. Non so se questo conta, ma ho pensato che fosse mannaia. Anche il personaggio dopo %è una scheda, ma per qualche motivo non si presenta come uno. Sto usando la notazione percentuale di Ruby per creare una stringa, che aggiunge i primi 2 argomenti passati allo script. C'è di più qui: http://teohm.com/blog/2012/10/15/start-using-ruby-percent-notation/