Irreversibilità rapporti tra grandezze fisiche differenti, al variare della potenza.

Consideriamo che un corridore percorre 1[km] in 3,29 [min] alla velocità di 19[km/h], vogliamo ricavare a quanti [km/h] deve andare per percorrere lo stesso km in 2,91 [min]; Eseguiamo la proporzione:

3,29 [min] / 19 [km/h] = 2,91 [min] / x [km/h];

Risolvendola otteniamo x = (2,91 * 19) / 3,29 = 16,8 [km/h]

oppure trasformando 19 [km/h] in [m/s] otteniamo 5,27[m/s] che utilizzati nella nuova proporzione forniscono:

3,29 [min] / 5,27[m/s] = 2,91 [min] / x [m/s];

Risolvendola otteniamo x = (2,91 * 5,27) / 3,29 = 4,66 [m/s]

Quindi si ha un paradosso della proporzione per l'incremento di velocità, la diminuzione del tempo non corrisponde ad un aumento di velocità, ma ad una diminuzione, che non corrisponde a realtà, ma può essere utilizata per conversioni monetarie ed altri tipologie, ma non relative ad una velocità. Questa rappresenta una proporzione inversa con relazione iperbolica fissata, ed in tal caso perde di significato fisico, poichè è fissato il punto lungo l'iperbole e la relazione diventa lineare.

Il modo corretto per esprimere l'aumento di velocità sarebbe quello di scrivere:

3,29 [min] * 5,27 [m/s] = 2,91 [min] * x [m/s]

otteniamo :

x = (3,29 * 5,27 ) / 2,91 = 5,958 [m/s]

Che è ottenuta attraverso una proporzione lineare (diretta) con relazione iperbolica non fissata, in tal caso non perde di significato fisico, ed il punto dell'iperbole viene fissato caso per caso.

Ora dimostriamo quanto detto nel titolo, ossia che si ha una Irreversibilità dei rapporti tra grandezze fisiche differenti, al variare della potenza. Trasformiamo

100 [km/h] in [m/s] -> (100 * 103) / (3,6 * 103) = 27,7 [m/s]

o anche più esplicitamente:

(100 * 103[m]) / (3,6 * 103[s]) = 27,7 [m/s]

Ora applichiamo la trasformata inversa:

27,7 [m/s] -> 27,7 [m/s] * 3,6 [s/m] = 100

in cui il valore non rappresenta più una velocità ma un numero adimensionale, che è privo di senso fisico.

Quindi il passaggio da [km/h] a [m/s] e poi da [m/s] a [km/h] non è reversibile affinchè vengano mantenute le stesse unità di misura.

Questa può essere estesa al caso generico in cui un rapporto di grandezze fisiche relazionate tra loro in modo inversamente proporzionale, dunque con un punto fissato dell'iperbole, se traslate per potenze inferiori o superiori di una quantità "c" che compare solo a numeratore o denominatore differente dall'unità (c ≠ 1)moltiplicata per multipli di 10n  (con n appartenente a tutti i valori dell'anello intero I) che possono apparire sia a numeratore che a denominatore, l'operazione ha una sola direzione fisica e risulta irreversibile dal punto di vista fisico, nel caso si decida di ritornare indietro, al valore precedente che lo ha generato, poichè presenta uguale valore ma dimensione indefinita, e quindi non più associabile allo stesso valore in termini di dimensioni, ma solo in termini di numeri.

Rotore di Rotore

∇ x∇ xA = -∇ 2A + ∇ (∇ A)

 

∇ ∇ = (/∂x + ∂/∂y + ∂/∂z) (∂/∂x + ∂/∂y + ∂/∂z) = ∂2/∂2x + ∂/∂y ∂/∂x + ∂/∂z ∂/∂x + ∂/∂x ∂/∂y + ∂2 /∂2y + ∂/∂y ∂/∂z + ∂/∂x ∂/∂z + ∂/∂y ∂/∂z + ∂2 /∂2z = (∂2/2x + ∂2 /∂2y + ∂2 /∂2z) + 2 ∂/∂x ∂/∂y + 2 ∂/∂x ∂/∂z + 2 ∂/∂z ∂/∂y

 

2 A = (∂2/2x + ∂2 /∂2y + ∂2 /∂2z) A

 

x∇ xA = -∇ 2A + ∇ (∇ A) = {2 ∂/∂x ∂/∂y + 2 ∂/∂x ∂/∂z + 2 ∂/∂z ∂/∂y} A

In cui si è ottenuto che il rotore di rotore del vettore A è uguale alla divergenza della divergenza di A meno il laplaciano di A, che è pari alla somma dei doppi prodotti delle derivate miste spaziali del vettore A.

AssertEquals() In JAVA

Attraverso questo articolo verificheremo il risultato di un assertEquals() in un testing nel linguaggio java, utilizzando come idea quella di verificare se una stringa passata in ingresso ed inviata attraverso un template con body e header, e convertita in un file CSV (comma separated values) e poi riconvertito il file da CSV a tipo String si ha una perdita, si ha una perdita di un carattere tra il primo ed il terzo set, e di un carattere tra il secondo ed il terzo set. Il software utilizzato per la compilazione e' Maven su shell linux. L'esempio e' scaricabile dal codice del libro "Camel in Action" al capitolo 3.

La classe che suddivide le  stringhe del processo e' la classe process:

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package camelinaction;

import org.apache.camel.Exchange;
import org.apache.camel.Processor;

/**
 * A processor which translates an order in custom inhouse format
 * to a CSV format
 *
 * @version $Revision$
 */
public class OrderToCsvProcessor implements Processor {

    public void process(Exchange exchange) throws Exception {
        String custom = exchange.getIn().getBody(String.class);

        String id = custom.substring(0, 9);
        String customerId = custom.substring(10, 19);
        String date = custom.substring(20, 29);
        String items = custom.substring(30);
        String[] itemIds = items.split("@");

        StringBuilder csv = new StringBuilder();
        csv.append(id.trim());
        csv.append(",").append(date.trim());
        csv.append(",").append(customerId.trim());
        for (String item : itemIds) {
            csv.append(",").append(item.trim());
        }

        exchange.getIn().setBody(csv.toString());
    }

}
Come si vede suddivide la  stringa in ingresso, in sotto stringhe in set da 0 a 9, da 10 a 19, da 20 a 29, trentesima. Costruisce il file CSV inserendo ogni comma appendendolo all'attributo base csv, separando ogni campo con la virgola o comma o colon. Alla fine inserisce il corpo csv di tipo String  nel nuovo exchange.

Ora faremo la verifica utilizzando il test e l'assertEquals con maven e vedremo che la verifica di uguaglianza delle stringhe funziona solo con la perdita di un carattere tra una cogiunzione di sottostringhe e l'altra

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package camelinaction;

import java.io.File;

import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.test.junit4.CamelTestSupport;
import org.junit.Test;

/**
 * @version $Revision$
 */
public class OrderToCsvProcessorTest extends CamelTestSupport {

    @Test
    public void testOrderToCsvProcessor() throws Exception {
        // this is the inhouse format we want to transform to CSV
        String inhouse = "0000004444000001212320091208  1217@1478@2132";
        template.sendBodyAndHeader("direct:start", inhouse, "Date", "20091208");
   File file = new File("target/orders/received/report-20091208.csv");
        assertTrue("File should exist", file.exists());

        // compare the expected file content
        String body = context.getTypeConverter().convertTo(String.class, file);
        assertEquals("000000444,20091208,000001212,1217,1478,2132", body);
    }

    @Override
    protected RouteBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            @Override
            public void configure() throws Exception {
                from("direct:start")
                    // format inhouse to csv using a processor
                    .process(new OrderToCsvProcessor())
                    // and save it to a file
                    .to("file://target/orders/received?fileName=report-${header.Date}.csv");
            }
        };
    }
}
Utilizzando Maven per la classe test che precedeva otteniamo:

[root@localhost transform]# mvn test -Dtest=OrderToCsvProcessorTest
[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building Camel in Action :: Chapter 3 :: Data Transformation 1.0.0
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.4.3:resources (default-resources) @ chapter3-transform ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /usr/camel/camelinaction-2.12.2/chapter3/transform/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:2.5:compile (default-compile) @ chapter3-transform ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-resources-plugin:2.4.3:testResources (default-testResources) @ chapter3-transform ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 5 resources
[INFO]
[INFO] --- maven-compiler-plugin:2.5:testCompile (default-testCompile) @ chapter3-transform ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-surefire-plugin:2.5:test (default-test) @ chapter3-transform ---
[INFO] Surefire report directory: /usr/camel/camelinaction-2.12.2/chapter3/transform/target/surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running camelinaction.OrderToCsvProcessorTest
2014-07-05 23:31:17,058 [main           ] INFO  OrderToCsvProcessorTest        - ********************************************************************************
2014-07-05 23:31:17,059 [main           ] INFO  OrderToCsvProcessorTest        - Testing: testOrderToCsvProcessor(camelinaction.OrderToCsvProcessorTest)
2014-07-05 23:31:17,059 [main           ] INFO  OrderToCsvProcessorTest        - ********************************************************************************
2014-07-05 23:31:17,701 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) is starting
2014-07-05 23:31:18,234 [main           ] INFO  DefaultCamelContext            - StreamCaching is not in use. If using streams then its recommended to enable stream caching. See more details at http://camel.apache.org/stream-caching.html
2014-07-05 23:31:18,244 [main           ] INFO  DefaultCamelContext            - Route: route1 started and consuming from: Endpoint[direct://start]
2014-07-05 23:31:18,244 [main           ] INFO  DefaultCamelContext            - Total 1 routes, of which 1 is started.
2014-07-05 23:31:18,250 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) started in 0.544 seconds
2014-07-05 23:31:18,446 [main           ] INFO  OrderToCsvProcessorTest        - ********************************************************************************
2014-07-05 23:31:18,446 [main           ] INFO  OrderToCsvProcessorTest        - Testing done: testOrderToCsvProcessor(camelinaction.OrderToCsvProcessorTest)
2014-07-05 23:31:18,446 [main           ] INFO  OrderToCsvProcessorTest        - Took: 0.195 seconds (195 millis)
2014-07-05 23:31:18,446 [main           ] INFO  OrderToCsvProcessorTest        - ********************************************************************************
2014-07-05 23:31:18,448 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) is shutting down
2014-07-05 23:31:18,450 [main           ] INFO  DefaultShutdownStrategy        - Starting to graceful shutdown 1 routes (timeout 10 seconds)
2014-07-05 23:31:18,487 [ - ShutdownTask] INFO  DefaultShutdownStrategy        - Route: route1 shutdown complete, was consuming from: Endpoint[direct://start]
2014-07-05 23:31:18,488 [main           ] INFO  DefaultShutdownStrategy        - Graceful shutdown of 1 routes completed in 0 seconds
2014-07-05 23:31:18,493 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) uptime 0.793 seconds
2014-07-05 23:31:18,494 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) is shutdown in 0.045 seconds
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.135 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 7.210s
[INFO] Finished at: Sat Jul 05 23:31:18 CEST 2014
[INFO] Final Memory: 7M/89M
[INFO] ------------------------------------------------------------------------

Ora proveremo ad inserire la stringa in ingresso con i valori corretti, senza piu' una perdita, tra un subset e l'altro, quindi la classe "OrderToCsvProcessorTest.java" diventa:

public class OrderToCsvProcessorTest extends CamelTestSupport {

    @Test
    public void testOrderToCsvProcessor() throws Exception {
        // this is the inhouse format we want to transform to CSV
        String inhouse = "0000004444000001212320091208  1217@1478@2132";
        template.sendBodyAndHeader("direct:start", inhouse, "Date", "20091208");

        File file = new File("target/orders/received/report-20091208.csv");
        assertTrue("File should exist", file.exists());

        // compare the expected file content
        String body = context.getTypeConverter().convertTo(String.class, file);
        assertEquals("0000004444,320091208,000001212,1217,1478,2132", body);
    }

    @Override
    protected RouteBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            @Override
            public void configure() throws Exception {
                from("direct:start")
                    // format inhouse to csv using a processor
                    .process(new OrderToCsvProcessor())
                    // and save it to a file
                    .to("file://target/orders/received?fileName=report-${header.Date}.csv");
            }
        };
    }
}
 Otteniamo:

[root@localhost transform]# mvn test -Dtest=OrderToCsvProcessorTest
[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building Camel in Action :: Chapter 3 :: Data Transformation 1.0.0
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.4.3:resources (default-resources) @ chapter3-transform ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /usr/camel/camelinaction-2.12.2/chapter3/transform/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:2.5:compile (default-compile) @ chapter3-transform ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-resources-plugin:2.4.3:testResources (default-testResources) @ chapter3-transform ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 5 resources
[INFO]
[INFO] --- maven-compiler-plugin:2.5:testCompile (default-testCompile) @ chapter3-transform ---
[INFO] Compiling 1 source file to /usr/camel/camelinaction-2.12.2/chapter3/transform/target/test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.5:test (default-test) @ chapter3-transform ---
[INFO] Surefire report directory: /usr/camel/camelinaction-2.12.2/chapter3/transform/target/surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running camelinaction.OrderToCsvProcessorTest
2014-07-05 23:39:13,391 [main           ] INFO  OrderToCsvProcessorTest        - ********************************************************************************
2014-07-05 23:39:13,392 [main           ] INFO  OrderToCsvProcessorTest        - Testing: testOrderToCsvProcessor(camelinaction.OrderToCsvProcessorTest)
2014-07-05 23:39:13,392 [main           ] INFO  OrderToCsvProcessorTest        - ********************************************************************************
2014-07-05 23:39:13,821 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) is starting
2014-07-05 23:39:14,122 [main           ] INFO  DefaultCamelContext            - StreamCaching is not in use. If using streams then its recommended to enable stream caching. See more details at http://camel.apache.org/stream-caching.html
2014-07-05 23:39:14,131 [main           ] INFO  DefaultCamelContext            - Route: route1 started and consuming from: Endpoint[direct://start]
2014-07-05 23:39:14,132 [main           ] INFO  DefaultCamelContext            - Total 1 routes, of which 1 is started.
2014-07-05 23:39:14,137 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) started in 0.312 seconds
2014-07-05 23:39:14,303 [main           ] INFO  OrderToCsvProcessorTest        - ********************************************************************************
2014-07-05 23:39:14,307 [main           ] INFO  OrderToCsvProcessorTest        - Testing done: testOrderToCsvProcessor(camelinaction.OrderToCsvProcessorTest)
2014-07-05 23:39:14,308 [main           ] INFO  OrderToCsvProcessorTest        - Took: 0.164 seconds (164 millis)
2014-07-05 23:39:14,308 [main           ] INFO  OrderToCsvProcessorTest        - ********************************************************************************
2014-07-05 23:39:14,310 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) is shutting down
2014-07-05 23:39:14,312 [main           ] INFO  DefaultShutdownStrategy        - Starting to graceful shutdown 1 routes (timeout 10 seconds)
2014-07-05 23:39:14,332 [ - ShutdownTask] INFO  DefaultShutdownStrategy        - Route: route1 shutdown complete, was consuming from: Endpoint[direct://start]
2014-07-05 23:39:14,333 [main           ] INFO  DefaultShutdownStrategy        - Graceful shutdown of 1 routes completed in 0 seconds
2014-07-05 23:39:14,336 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) uptime 0.516 seconds
2014-07-05 23:39:14,336 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.12.2 (CamelContext: camel-1) is shutdown in 0.026 seconds
Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 1.353 sec <<< FAILURE!

Results :
Failed tests:
  testOrderToCsvProcessor(camelinaction.OrderToCsvProcessorTest)

Tests run: 1, Failures: 1, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 6.255s
[INFO] Finished at: Sat Jul 05 23:39:14 CEST 2014
[INFO] Final Memory: 13M/89M
[INFO] ------------------------------------------------------------------------
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.5:test (default-test) on project chapter3-transform: There are test failures.
[ERROR]
[ERROR] Please refer to /usr/camel/camelinaction-2.12.2/chapter3/transform/target/surefire-reports for the individual test results.
[ERROR] -> [Help 1]
[ERROR]
[ERROR] To see the full stack trace of the errors, re-run Maven with the -e switch.
[ERROR] Re-run Maven using the -X switch to enable full debug logging.
[ERROR]
[ERROR] For more information about the errors and possible solutions, please read the following articles:
[ERROR] [Help 1] http://cwiki.apache.org/confluence/display/MAVEN/MojoFailureException

Come vediamo otteniamo un errore comunque posizioniamo i caratteri di confronto, l'unico modo possibile per non ottenere un errore e' il primo, in cui l'assertEquals() funziona correttamente. Quindi possiamo dedurre che l'errore di uguaglianza che si presentava per i codici C e derivati si presenta sotto diversa forma, ma sempre nell'asserire un uguaglianza , con il linguaggio JAVA. Oppure possiamo trovare la giustificazione che la perdita non si ha nell'asserzione, ma nella criptazione e decriptazione della stringa, che costringe al confronto l'assertEquals con valori differenti da quelli iniziali.










 

Rotore del Rotore

∇ x∇ xA = -∇ 2A + ∇ (∇ A)

 

∇ ∇ = (/∂x + ∂/∂y + ∂/∂z) (∂/∂x + ∂/∂y + ∂/∂z) = ∂2/∂2x + ∂/∂y ∂/∂x + ∂/∂z ∂/∂x + ∂/∂x ∂/∂y + ∂2 /∂2y + ∂/∂y ∂/∂z + ∂/∂x ∂/∂z + ∂/∂y ∂/∂z + ∂2 /∂2z = (∂2/2x + ∂2 /∂2y + ∂2 /∂2z) + 2 ∂/∂x ∂/∂y + 2 ∂/∂x ∂/∂z + 2 ∂/∂z ∂/∂y

 

2 A = (∂2/2x + ∂2 /∂2y + ∂2 /∂2z) A

 

x∇ xA = -∇ 2A + ∇ (∇ A) = {2 ∂/∂x ∂/∂y + 2 ∂/∂x ∂/∂z + 2 ∂/∂z ∂/∂y} A

In cui si è ottenuto che il rotore di rotore del vettore A è uguale alla divergenza della divergenza di A meno il laplaciano di A, che è pari alla somma dei doppi prodotti delle derivate miste spaziali del vettore A.

Assegnamento di Array a Puntatori in C

Utilizzando gcc come compilatore su Linux dimostreremo che l'assegnamento di un array ad un puntatore non e' possibile se non per i soli primi tre elementi dell'array, nel caso di funzioni esterne al main, eventuali altre funzioni  che utilizzano cicli iterativi per l'assegnamento dei singoli elementi provocano "segmentation fault". Ovviamente questo implica anche che non sia possibile assegnare una stringa di lunghezza variabile (con scanf) ad un puntatore esterno al main, infatti il valore assegnato per default al puntatore e' di 4 caratteri con conseguente perdita di valori per stringhe superiori a 4 nel caso debba essere fatta una ricerca con una funzione al di fuori del main, in C, e' solo possibile il passaggio per riferimento di un array, di lunghezza variabile ottenuto con scanf. Inoltre non esistono funzioni delle librerie C, utilizzate anche dal C++, C++11 e dal Objective-C, che  forniscono una sottostringa ricercata all'interno di un vettore testo, quindi in C e derivati la ricerca di una stringa ottenuta da un utente esterno rispetto al testo conosciuto puo' essere fatta se all'interno della funzione si include lo scanf() con l'array a lunghezza variabile che mantiene una dimensione superiore a 4 per la durata della funzione. Vedremo inoltre che l'operatore di assegnamento == non riconosce i caratteri char tra gli elementi di un array e l'altro, mentre il Java li riconosce. Poi proveremo ad avvicinarci alla logica numerica del C, supponendo per assurdo di dover riscrivere una codifica ASCII, o un alfabeto associato a degli interi in ingresso, e vedremo che in tal caso l'operatore di assegnamento == funziona, ma la logica iterativa dei cicli for e while, identici a quelli utilizzati per il Java, diventa instabile e fornisce risposte differenti asseconda, della quantita' e del valore dei codici numerici inseriti.

Il codice C e' il seguente:

# include <stdio.h>
# include <stdlib.h>
# include <string.h>
int dim =0;
int dimRidondante =0;
int dim2 = 0;
int dim3 = 0;
int i;
char *p;
char array[];
void stampaPuntatoreUndef(int dimensione, char *p);
void stampArray(int dimensione, char array[]);
void assegnamentoArrayAPuntatore(int  dimensioneArray, char array[]);
void main(){
  printf("inserire la lunghezza della stringa: \n");
  scanf("%d",&dim);
  printf("inserire la  stringa:\n");
  for(i=0; i<=dim; i++){
    scanf("%c",&array[i]);
    //p++;
  }
  dim2 = strlen(array);
  printf("la dimensione dell'array e':%d\n", dim2);
  stampArray(dim2, array);
  //assegnamentoArrayAPuntatore(dim2, array);
  p=array;
 
  dimRidondante = strlen(p);
  printf("la dimensione letta del puntatore e':%d\n",dimRidondante);
  dim3 = strlen(array);
  printf("la dimensione dell'array dopo l'assegnamento e':%d\n", dim3);
  stampaPuntatoreUndef(dimRidondante, p);
  stampArray(dim2, array);
}
stampaPuntatoreUndef(int dimensione, char *p){
  int j;
  for(j=0; j<=dimensione;j++){
    printf("%c",*p);
    p++;
  }
  printf("\n");
}
void stampArray(int dimensione, char array[]){
  int i;
  for(i=0; i<dimensione;i++){
    printf("%c",array[i]);
  }
 printf("\n");
}
/*void assegnamentoArrayAPuntatore(int dimensioneArray, char array[]){
  int i;
  for(i=0;i<=dimensioneArray;i++){
    printf("i=%d   ",i);
    p[i]=array[i];
  }
}
*/

a video otteniamo con l'assegnamento normale:

assegnamento a puntatori in C 

In cui in basso compare il programma con i commenti come riportato nel codice di su, mentre in alto compare l'output del programma senza i commenti, utilizzando anziche' il normale assegnamento = la funzione assegnamentoArrayAPuntatore.

Nel programma in basso con l'assegnamento = si nota che il segmentation fault avviene in modo implicito dopo l'assegnazionne del terzo elemento in cui prova diventa proh?.

Mentre nel programma in alto in cui la funzione assegna elemento per elemento i valori dell'array al puntatore con l'aritmetica dei puntatori si ha un segmentation fault esplicito.

Tra un esecuzione e l'altra del codice sono presenti i risultati di compilazione da parte di gcc. Mentre il nome stampaPuntatoreUndef che segue i simboli ./ identifica l'esecuzione del codice. Il titolo Undef identifica che la lunghezza della stringa in ingresso e' variabile ed assegnata dall'esterno, come se  fosse inserita per un find successivo. Mentre l'aritmetica dei puntatori e l'assegnamento funziona se la stringa e' passata direttamente nel codice da compilare. Quindi si conclude che i puntatori non possono essere utilizzati nel caso di stringhe  a lunghezza variabile inserite dall'esterno. Mentre funzionano bene per stringhe preinserite, nel codice e poi compilate.

***************************************************************************************************************************************

Ora vedremo una funzione di ricerca che  passa i parametri per riferimento, perdendo cosi' la dimensione dell'array, per dimensioni superiori a 4.

Il codice e':

#include <stdio.h>
#include <stdlib.h>
char arrayStringheSenzaNull[]="ti voglio tanto bene";
void ricercaStringa(char s[], int dim, char find[]);
char trova[];
void stampaLaParola(char find[]);
int dimensione, dimensioneVettore;
int indice = 0;
char parolaSmezzata[];
char parola;
int dimensioneParola=0;
int dim = 0;
int i;
int y=0;
int count = 0;
void main(){
  printf("Inserire la lunghezza della parola da cercare:");
  scanf("%d", &dimensioneParola);
  printf("Inserire la parola da cercare:");
  for(i=0;i<=dimensioneParola;i++){
  scanf("%c",&trova[i]);
  }
  dimensioneVettore = sizeof(arrayStringheSenzaNull);
  printf("dimensioneParola == %d in main\n", dimensioneParola);
  ricercaStringa(arrayStringheSenzaNull, dimensioneVettore, trova);
}
ricercaStringa(char s[], int dimensioneVettore, char find[]){
 
  printf("sono dentro ricerca stringa\n");
  if( count==0){
    dimensioneParola = sizeof(find);
    printf("dimensioneParola==%d in ricerca stringa\n",dimensioneParola);
    count++;
  }
  while(y<dimensioneVettore){
  for(i=0; ((i<dimensioneVettore)&&(s[i]== find[indice]));){
    printf("sono dentro il for di ricercaStringa fuori dall'if\n");
    if(s[i]== find[indice]){
    indice++;
    printf("sono dentro l'if del for di ricerca stringa\n");
    dim = sizeof(find)/sizeof(find[0]);
    int k=0;
    int j=0;
    while(j<dim ){
      parolaSmezzata[j] = find[k];
      j++;
      k++;
    } i++;
    ricercaStringa(find, dimensioneParola, parolaSmezzata);
    }
  }
  y++;
  }
  printf("y == %d, dimensioneVettore == %d, i == %d\n",y, dimensioneVettore, i);
  return ((y==dimensioneVettore)?stampaLaParola(find):printf("parolaNonTrovata\n"));
}
stampaLaParola(char find[]){
  int i=0;
  printf("sono dentro stampa la  parola\n");
  int dimensioneParola = sizeof(find);
  printf("La dimensione della parola e':%d",dimensioneParola);
  for(i; i<dimensioneParola ; i++ ){
    printf("%c",find[i]);
  }
  printf("\n");
}

L'output ottenuto con gcc e':

[root@localhost find]# gcc -Wall RicercaStringa.c -o RicercaStringa
RicercaStringa.c:16:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
RicercaStringa.c:27:1: warning: return type defaults to ‘int’ [-Wreturn-type]
RicercaStringa.c:27:1: warning: conflicting types for ‘ricercaStringa’ [enabled by default]
RicercaStringa.c:4:6: note: previous declaration of ‘ricercaStringa’ was here
RicercaStringa.c:57:1: warning: return type defaults to ‘int’ [-Wreturn-type]
RicercaStringa.c:57:1: warning: conflicting types for ‘stampaLaParola’ [enabled by default]
RicercaStringa.c:6:6: note: previous declaration of ‘stampaLaParola’ was here
RicercaStringa.c: In function ‘stampaLaParola’:
RicercaStringa.c:62:3: warning: statement with no effect [-Wunused-value]
RicercaStringa.c: At top level:
RicercaStringa.c:5:6: warning: array ‘trova’ assumed to have one element [enabled by default]
RicercaStringa.c:9:6: warning: array ‘parolaSmezzata’ assumed to have one element [enabled by default]
[root@localhost find]# ./RicercaStringa
Inserire la lunghezza della parola da cercare:5
Inserire la parola da cercare:bene
dimensioneParola == 5 in main
sono dentro ricerca stringa
dimensioneParola==4 in ricerca stringa
y == 21, dimensioneVettore == 21, i == 0
sono dentro stampa la  parola
La dimensione della parola e':4
ben

in cui si nota la perdita della dimensione della parola cercata.

Non sono presenti funzioni che restituiscano la stringa in <string.h>

*****************************************************************************************************************************************

Resta da dimostrare che con lo scanf() all'interno della funzione di ricerca sia possibile trovare una stringa ricercata in un vettore di testo in C.

Questo non e' possibile poiche' l'operatore di uguaglianza in C ==, non confronta gli elementi dell'array all'interno di un ciclo, lo dimostriamo utilizzando il seguente codice  che ovvia al problema della perdita di dimensione del vettore con il passaggio di parametri per riferimento, poiche' inseriamo direttamente nella funzione lo scanf(), pero' l'operatore di assegnamento non riconosce l'uguaglianza tra singolo carattere di due stringhe, in cui una e' un vettore stringa composto da piu' stringhe ed una e' la sottostringa. Il codice e' il seguente:

#include <stdio.h>
#include <stdlib.h>
# include <string.h>
char arrayStringheSenzaNull[]="ti voglio tanto bene";
//void ricercaStringa(char s[], int dim, char find[]);
void ricercaStringa();
int  dimensioneVettore=0;
int dimensioneParola=0;
int b=0;
char trova[];
void main(){
  ricercaStringa();
}
ricercaStringa(){
  int k=0;
  int y=0;
  int i=0;
  //char trova[];
  printf("Inserire la lunghezza della parola da cercare:");
  scanf("%d", &dimensioneParola);
  printf("Inserire la parola da cercare:");
  for(b=0;b<=dimensioneParola;b++){
  scanf("%c",&trova[b]);
  }
    dimensioneVettore = sizeof(arrayStringheSenzaNull);
    printf("dimensioneVettore == %d,\n", dimensioneVettore);
    dimensioneParola = strlen(trova);
    printf("dimensioneParola==%d in ricerca stringa\n",dimensioneParola);
 
    while(k<dimensioneVettore){
      printf("sono dentro il while\n");
  if(arrayStringheSenzaNull[k]== trova[0]){
    printf("sono dentro il primo if di ricercaStringa ho trovato la prima corrispondenza\n");
    for(y=0; y<= dimensioneParola; y++){
      if(arrayStringheSenzaNull[k]==trova[y]){
    k++;
    printf("Sono dentro l'if ho trovato la corrispondenza n:%d\n",y);
    if(y==dimensioneParola){
      printf("la parola cercata e' stata trovata ed e':\n");
    }
      }
    }
    //ricercaStringa(find, dimensioneParola, parolaSmezzata);
    //implica che non si possa fare una ricerca ricorsiva, per via del passaggio
    //di paramentri per riferimento per valore
  }
  k++;
  }
 }

Compilando con gcc ed inserendo la dimensione dell'array e successivamente la  stringa: "bene" appartenente al vettore stringa principale "ti voglio tanto bene", notiamo  che non viene riconoscuita l'uguaglianza nel confronto tra i singoli elementi, e notiamo che la percorrenza del vettore Stringa principale di 21 caratteri viene eseguito, in quanto "sono dentro il while" compare per 21 volte.

[root@localhost find]# gcc -Wall RicercaStringaNoMain.c -o RicercaStringaNoMain
RicercaStringaNoMain.c:11:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
RicercaStringaNoMain.c:14:1: warning: return type defaults to ‘int’ [-Wreturn-type]
RicercaStringaNoMain.c:14:1: warning: conflicting types for ‘ricercaStringa’ [enabled by default]
RicercaStringaNoMain.c:6:6: note: previous declaration of ‘ricercaStringa’ was here
RicercaStringaNoMain.c: In function ‘ricercaStringa’:
RicercaStringaNoMain.c:17:7: warning: unused variable ‘i’ [-Wunused-variable]
RicercaStringaNoMain.c: At top level:
RicercaStringaNoMain.c:10:6: warning: array ‘trova’ assumed to have one element [enabled by default]
[root@localhost find]# ./RicercaStringaNoMain
Inserire la lunghezza della parola da cercare:5
Inserire la parola da cercare:bene
dimensioneVettore == 21,
dimensioneParola==6 in ricerca stringa
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
[root@localhost find]#

Per quanto riguarda il C oltre ad una ricerca iterativa ovviamente non e' possibile la ricerca ricorsiva per via  della perdita della dimensione dell'array nel passaggio per riferimento tra una  funzione e l'altra.

Ora resta da dimostrare se con la ridefinizione dell'operatore di uguaglianza == in C++, sia possibile tale confronto. Poiche' in C abbiamo visto che non e' possibile  la gestione delle stringhe.
Possiamo iniziare col dire che nello Stroustrup (3a edizione) stampa anno 2012 mese di settembre non compare la ridefinizione dell'operatore di uguaglianza. Si ricorda che Bjarne Stroustrup e' il creatore del C++.

Si puo' dire che il C++ si basa sul C, e la ridefinizione degli operatori in realta' e' un overload degli operatori, e tale sovraccarico si riferisce sempre agli operatori base del C, quindi se non funziona in C l'operatore di uguaglianza per le  stringhe  di un array non puo' funzionare neanche in C++, come possiamo vedere dall'esempio  che conferma la  teoria sul riferimento al confronto del linguaggio base.

Overload Dell'operatore di assegnamento

*****************************************************************************************************************************************

Vedremo se e' possibile il confronto tra stringhe  in Java.
In Java e' possibile la ricerca di una sottostringa all' interno di una stringa il cui tipo e' char per entrambe. Quindi sotto questo profilo il Java e' superiore al C.

Il codice e' il seguente, (il compilatore usato e' quello fornito dalla JDK, "javac" e la "java" e' l'esecutore), non utilizzeremo nessun IDE:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class ricercaString{
    static char arrayStringheSenzaNull[]={'T','i',' ','v','o','g','l','i','o',' ','t','a','n','t','o',' ','b','e','n','e'};
  public static void ricercaString() throws IOException{
    int k=0;
    int y=0;
    int g=0;
    int indice=0;
    String theString;
    System.out.printf("Inserire la lunghezza della parola da cercare:\n");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String stringa = br.readLine();
    int dimensioneParola = Integer.parseInt(stringa);
    System.out.printf("Inserire la parola da cercare:");
    //char trova[] = br.readLine();//verificare se occorre un for
    // char trova[0] = (char) System.in.read();
    Scanner s = new Scanner(System.in);
    //char trova = (char) s.nextLine();
    theString = s.nextLine();
    char trova[] = theString.toCharArray();    
    int dimensioneVettore = arrayStringheSenzaNull.length;
    System.out.printf("dimensione vettore == %d, ", dimensioneVettore);
     dimensioneParola = trova.length;
    System.out.printf(" dimensioneParola==%d in ricerca stringa\n",dimensioneParola);
    System.out.printf("la parola inserita e':");
    for(g=0;g<dimensioneParola;g++){
      System.out.printf("%c", trova[g]);
    }
    System.out.println();
    while(k<dimensioneVettore){
      System.out.println("sono dentro il while");
  if(arrayStringheSenzaNull[k]== trova[0]){
    System.out.println("sono dentro il primo if di ricercaStringa ho trovato la prima corrispondenza\n");
    for(y=0; y<dimensioneParola; y++){
      if(arrayStringheSenzaNull[k]==trova[y]){
    System.out.printf("Sono dentro l'if ho trovato la corrispondenza n:%d\n",y);
    if(y==(dimensioneParola-1)){
      System.out.printf("la parola cercata e' stata trovata ed e':");
      for(g=0;g<dimensioneParola;g++){
        System.out.printf("%c", trova[g]);
        }
        System.out.println();
      indice=k-y;
    System.out.printf("Corrisponde all'indice:%d",indice);
    System.out.println();
    }
      }
    k++;
    }
    //System.out.printf("Dimensione vettore: %d valore di k:%d\n",dimensioneVettore,k);
    //ricercaStringa(find, dimensioneParola, parolaSmezzata);
    //implica che si possa fare una ricerca ricorsiva,
  }
  k++;
  }
  }
public static void main(String[] args) throws IOException{
 
  ricercaString();
  }
}

l'esecuzione attraverso la virtual machine fornisce:

[root@localhost Java]# javac ricercaString.java
[root@localhost Java]# java ricercaString
Inserire la lunghezza della parola da cercare:
4
Inserire la parola da cercare:bene
dimensione vettore == 20,  dimensioneParola==4 in ricerca stringa
la parola inserita e':bene
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la prima corrispondenza

Sono dentro l'if ho trovato la corrispondenza n:0
Sono dentro l'if ho trovato la corrispondenza n:1
Sono dentro l'if ho trovato la corrispondenza n:2
Sono dentro l'if ho trovato la corrispondenza n:3
la parola cercata e' stata trovata ed e':bene
Corrisponde all'indice:16
[root@localhost Java]#

In cui si nota che l'operatore di uguaglianza per caratteri char, in Java funziona, ed e' possibile la ricerca di sottostringhe in stringhe, nel caso di char.

Ora verificheremo che e' possibile utilizzando anche il tipo String.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;


public class ricercaString{
    //static char arrayStringheSenzaNull[]={'T','i',' ','v','o','g','l','i','o',' ','t','a','n','t','o',' ','b','e','n','e'};
    static String arrayStringhe ="Ti voglio tanto bene";
  public static void ricercaString() throws IOException{
    int i=0;
    String trova;
    System.out.printf("Inserire la lunghezza della parola da cercare:\n");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String stringa = br.readLine();
    int dimensioneParola = Integer.parseInt(stringa);
    System.out.printf("Inserire la parola da cercare:");
    //char trova[] = br.readLine();//verificare se occorre un for
    // char trova[0] = (char) System.in.read();
    Scanner s = new Scanner(System.in);
    //char trova = (char) s.nextLine();
    trova = s.nextLine();
    int dimensioneVettore = arrayStringhe.length();
    System.out.printf("dimensione vettore == %d, ", dimensioneVettore);
     dimensioneParola = trova.length();
    System.out.printf(" dimensioneParola==%d in ricerca stringa\n",dimensioneParola);
    System.out.printf("la parola inserita e':%s\n",trova);
    while(i<dimensioneVettore){
    if(arrayStringhe.regionMatches(i, trova, 0, dimensioneParola)){
     System.out.printf("La parola ");
     System.out.println(arrayStringhe.substring(i));
     System.out.printf("e' stata trovata all'indice: %d\n",i);
    }
    i++;
      }
    }

public static void main(String[] args) throws IOException{
  ricercaString();
  //ricercaChar();
  }
}

l'esecuzione e':

[root@localhost Java]# javac ricercaString.java
[root@localhost Java]# java ricercaString
Inserire la lunghezza della parola da cercare:
4
Inserire la parola da cercare:bene
dimensione vettore == 20,  dimensioneParola==4 in ricerca stringa
la parola inserita e':bene
La parola bene
e' stata trovata all'indice: 16
[root@localhost Java]#

*****************************************************************************************************************************************

Ora proveremo ad avvicinarci alla logica C, in cui l'operatore di assegnamento funziona solo per di tipo intero, e la ridefinizione di tale operatore per i linguaggi derivati puo' essere fatta solo considerando il tipo int; Ma ci accorgeremo che nonostante l'operatore di assegnamento funzioni, la logica iterativa, che e' la stessa di quella inserita nel Java, diventa instabile, e non funziona correttamente, fornendo risposte differenti asseconda della quantita' e del valore inserito dei numeri in ingresso.

Convertiamo in formato numerico  la stringa ASCII "ti voglio tanto bene" (ovviamente per stringhe derivanti dal latino), della quale consideriamo il Lower case:

ti voglio tanto bene=116,105,32,118,111,103,108,105,111,32,116,97,110,116,110,116,110,32,98,101,110,101

Il codice e' il seguente:

#include <stdio.h>
#include <stdlib.h>
# include <string.h>
int arrayInt[]={116,105,32,118,111,103,108,105,111,32,116,97,110,116,110,116,110,32,98,101,110,101};
void ricercaStringaNumerica();
int dimensioneStringa=0;
int dimensioneArray=0;
int trova[];
void main(){
  ricercaStringaNumerica();
}
ricercaStringaNumerica(){
  int i;
  int y;
  int k=0;
  int b=0;
  printf("Inserire la lunghezza della parola da cercare:\n");
  scanf("%d",&dimensioneStringa);
  printf("Inserire la stringa numerica in decimale:\n");
  for(i=0; i<dimensioneStringa;i++){
    scanf("%d",&trova[b]);//probabilmente e' necessario inserire ogni numero dopo invio
  }
  dimensioneArray= sizeof(arrayInt)/sizeof(arrayInt[0]);
  printf("dimensione Array interi == %d,\n", dimensioneArray);
  printf("dimensione Stringa numerica in ingresso == %d\n", dimensioneStringa);
 
  while(k<=dimensioneArray){
    printf("sono dentro il while\n");
    if(arrayInt[k]==trova[0]){
      printf("sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza\n");
      for(y=0; y<=dimensioneStringa;y++){
    if(arrayInt[k]==trova[y]){
      k++;
      printf("sono dentro l'if ho trovato la corrispondenza n:%d\n",y);
      if(y==dimensioneStringa){
        printf("la parola cercata e' stata trovata ed  e':\n");
      }
    }
      }
    }
    k++;
  }
}

La compilazione e l'esecuzione forniscono il seguente risultato:

[root@localhost find]# gcc -Wall RicercaDecimalePerStringa.c -o RicercaDecimalePerStringa
RicercaDecimalePerStringa.c:9:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
RicercaDecimalePerStringa.c:12:1: warning: return type defaults to ‘int’ [-Wreturn-type]
RicercaDecimalePerStringa.c:12:1: warning: conflicting types for ‘ricercaStringaNumerica’ [enabled by default]
RicercaDecimalePerStringa.c:5:6: note: previous declaration of ‘ricercaStringaNumerica’ was here
RicercaDecimalePerStringa.c:8:5: warning: array ‘trova’ assumed to have one element [enabled by default]
[root@localhost find]# ./RicercaDecimalePerStringa
Inserire la lunghezza della parola da cercare:
2
Inserire la stringa numerica in decimale:
116
105
dimensione Array interi == 22,
dimensione Stringa numerica in ingresso == 2
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
[root@localhost find]# ./RicercaDecimalePerStringa
Inserire la lunghezza della parola da cercare:
3
Inserire la stringa numerica in decimale:
101
110
101
dimensione Array interi == 22,
dimensione Stringa numerica in ingresso == 3
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro l'if ho trovato la corrispondenza n:1
sono dentro l'if ho trovato la corrispondenza n:2
[root@localhost find]# ./RicercaDecimalePerStringa
Inserire la lunghezza della parola da cercare:
6
Inserire la stringa numerica in decimale:
118
111
103
108
105
111
dimensione Array interi == 22,
dimensione Stringa numerica in ingresso == 6
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
[root@localhost find]#

Per completezza sono stati inseriti in ingresso i valori: 116,105 poi 101,110,101 poi 118,111,103,108,105,111;

In cui si notano risposte completamente differenti e incorrette asseconda della lunghezza e della sequenza e quindi del valore della stringa fornita in ingresso. In Java invece con la stessa logica iterativa e utilizzando le stringhe  o char il codice funziona.

Vedremo se nel COBOL linguaggio utilizzato nelle banche  funziona l'operatore di assegnamento, per char. Poiche' in teoria si ha una conversione da linguaggio di alto livello ad un linguaggio macchina, anche se con il Java questo non sarebbe necessario le banche continuano ad usare il COBOL poiche' i loro database sono di vecchia data. In COBOL non e' possibile comparare gli array sia perche' vengono sostituiti da tabelle, sia perche' e' un linguaggio piu' obsoleto del C.