working on it ...

Filters

Explore Public Snippets

Sort by

Found 7 snippets

    public by Rafael G  11214  2  4  1

    WIP: script to auto-correct almost any program (the outputs should not contain "\n\n" though)

    WIP: script to auto-correct almost any program (the outputs should not contain "\n\n" though): examinator.rb
    ## Converting line endings to unix:
    inputs_file = File.open('./inputs.txt', 'a+')
    outputs_file = File.open('./outputs.txt', 'a+')
    
    input_file_contents = inputs_file.read.gsub(/\r\n?/,"\n")
    inputs_file.truncate(0)
    inputs_file.print input_file_contents
    
    outputs_file_contents = outputs_file.read.gsub(/\r\n?/,"\n")
    outputs_file.truncate(0)
    outputs_file.print outputs_file_contents
    
    inputs_file.close
    outputs_file.close
    
    #  Getting each input and each output into an array the idea is, basically, 
    # separate them each time we find an empty line ("\n").
    #  Should be noted though, that since the expected output should contain an
    # "\n" at its ending, so should each element on our array.
    
    inputs_file = File.open('./inputs.txt', 'r')
    outputs_file = File.open('./outputs.txt', 'r')
    
    inputs = []
    outputs = []
    
    loop do
      inputs_contents = inputs_file.gets('')
      outputs_contents = outputs_file.gets('')
      if inputs_contents.nil? || outputs_contents.nil?
        break
      else
        inputs_contents.gsub!("\n\n", "\n")
        outputs_contents.gsub!("\n\n", "\n")
        inputs << inputs_contents
        outputs << outputs_contents
      end
    end
    
    # To continue. Next step: get user's output.
    # Little snippet on how to get terminal's output below:
    
    test = __FILE__
    puts `ls #{test}`.class # It's a string.
    
    
    

    public by Rafael G  3905  3  3  0

    #sort #sorting #puc apc-b 2016

    #sort #sorting #puc apc-b 2016: mergesort.c
    #include <stdio.h>
    
    void merge(int v[], int inicio, int meio, int fim) {
      int aux[100];
      int aux_inicio = inicio, aux_meio = meio + 1, k=0;
      while(aux_inicio <= meio && aux_meio <= fim)
        if(v[aux_inicio] <= v[aux_meio])
          aux[k++] = v[aux_inicio++];
        else
          aux[k++] = v[aux_meio++];
          
      for(aux_inicio = aux_inicio; aux_inicio <= meio; aux_inicio++)
        aux[k++] = v[aux_inicio];
        
      for(aux_meio = aux_meio; aux_meio <= fim; aux_meio++)
        aux[k++] = v[aux_meio];
        
      k=0;
      
      for(aux_inicio = inicio; aux_inicio <= fim; aux_inicio++) //copia aux para v
        v[aux_inicio] = aux[k++];
    }
    
    void merge_sort(int v[], int inicio, int fim) {
      int meio = (inicio + fim) / 2;
      if(inicio < fim) {
          merge_sort(v, inicio, meio);
          merge_sort(v, meio + 1, fim);
          merge(v, inicio, meio, fim);
        }
    }
    
    int main (void) {
      int var[] = {0, 6, 4, 2, 16, 22, 3, 9};
      merge_sort(var, 0, 7);
      int i;
      for (i = 0; i < 8; i++)
        printf("%d ", var[i]);
      return 0;
    }
    
    

    public by Drowze  14126  0  4  0

    mim ajuda

    mim ajuda: mim_ajuda.rb
    require 'matrix'
    class Matrix
      def []=(i, j, x)
        @rows[i][j] = x
      end
    end
    
    class String # Only works for single letters; could be extended to uppercase letters too
      def step(c, delta=1)
        if c.ord + delta > 122 then
          return [c.ord + delta - 26].pack 'U'
        elsif c.ord + delta < 97 then
          return [c.ord + delta + 26].pack 'U'
        else
          return [c.ord + delta].pack 'U'
        end
      end
    
      def increment(c)
        return nil if self.size > 1
        c %= 26
        step self, c
      end
    
      def decrement(c)
        return nil if self.size > 1
        c %= 26
        step self, -c
      end
    end
    
    class Board
      attr_reader :cell_pairs
      MOVES = {
        'nw' => [-1, 0],
        'ne' => [-1, +1],
        'sw' => [+1, -1],
        'se' => [+1, 0]
      }
      CELL_CODES = Matrix[
        [0,0,0,0,0,1,3,3,3,2],
         [0,0,0,0,5,7,7,7,7,2],
          [0,0,0,5,7,7,7,7,7,2],
           [0,0,5,7,7,7,7,7,7,2],
            [0,5,7,7,7,7,7,7,7,2],
             [4,7,7,7,7,7,7,7,7,0],
              [4,7,7,7,7,7,7,7,0,0],
               [4,7,7,7,7,7,7,0,0,0],
                [4,7,7,7,7,7,0,0,0,0],
                 [4,7,7,7,7,0,0,0,0,0],
                  [0,0,0,0,0,0,0,0,0,0]
      ]
    
      CELL_PAIRS = module Cell_pairs # "Function" to prepare the cell_pairs
        cell_pairs = Hash.new
        start_letter = 'a'
        increment = 0
        checker = 0
        CELL_CODES.each_with_index do |element, row, col|
          if row <= 5
            if checker != row then # I get here everytime it goes to another row
              increment = -row + 5
              checker = row
            end
            if(element == 7) then
              cell_pairs["#{row} #{col}"] = "#{row.to_s}#{start_letter.increment(increment)}"
              increment += 2
            end
          else
            if checker != row then # I get here everytime it goes to another row
              increment = row - 5
              checker = row
            end
            if(element == 7) then
              cell_pairs["#{row} #{col}"] = "#{row.to_s}#{start_letter.increment(increment)}"
              increment += 2
            end
          end
        end
        cell_pairs
      end
    
    
    
      def self.prepare_board positions
        seq = [' ',1,2,3,4,5,6,7,8,9,' ']
        counter = 0
        indentation = 0
        ret = ''
    
        CELL_CODES.to_a.map.with_index do |m, i|
          if i != 10 then
            ret += seq[counter].to_s + ' ' * indentation 
            m.each_with_index do |n, j| 
              n == 7 ? ret += ("#{positions[i,j]} ") : ret += ('  ')  # piece occupying the cell
              [4,5,6,7].include?(n) ? ret += ('| ') : ret += ('  ') 
            end
            ret += "\n" + ' ' * indentation unless i == CELL_CODES.to_a.map.size-1
            m.each_with_index do |n|
              [2,3,6,7].include?(n) ? ret += ('\\ ') : ret += ('  ') 
              [1,3,5,7].include?(n) ? ret += ('/ ') : ret += ('  ') 
            end
            ret += "\n" 
            counter+=1 
            indentation+=2
          end
        end
        ret += ' ' * 15 + 'a b c d e f g h i j k l m n o' + "\n"
        ret
      end
    end
    
    print Board::CELL_PAIRS
    
    

    public by Drowze  2963  0  3  0

    Only simple letters for now

    Only simple letters for now: caesar.c
    #include <stdio.h>
    
    void caesar_cipher(FILE *input, FILE *output, int k){
      int ch;
      k %= 26; //26 indica uma volta completa, logo qualquer k>26 é excessivo
      do{
        ch = fgetc(input);
        if(ch >= 65 && ch <= 90) { //letra maiuscula? (valores de 'A' e 'Z' da tabela ASCII)
          ch += k;
          if(ch > 90) 
            ch -= 26; //se tiver passado do 'Z', subtrai uma volta completa
        }
        else
          if(ch >= 97 && ch <= 122) { //letra minuscula? (valores de 'a' e 'z' da tabela ASCII)
            ch += k;
            if(ch > 122) 
              ch -= 26; //se tiver passado do 'z', subtrai uma volta completa
          }
        if(ch != EOF)
          fputc(ch, output);
      }while(ch != EOF);
    }
    
    void caesar_decipher(FILE *input, FILE *output, int k){
      int ch;
      k %= 26; //26 indica uma volta completa, logo qualquer k>26 é excessivo
      do{
        ch = fgetc(input);
        if(ch >= 65 && ch <= 90) { //letra maiuscula? (valores de 'A' e 'Z' da tabela ASCII)
          ch -= k;
          if(ch < 65) 
            ch += 26; //se tiver passado do 'A', soma uma volta completa
        }
        else
          if(ch >= 97 && ch <= 122) { //letra minuscula? (valores de 'a' e 'z' da tabela ASCII)
            ch -= k;
            if(ch < 97) 
              ch += 26; //se tiver passado do 'a', soma uma volta completa
          }
        if(ch != EOF)
        fputc(ch, output);
      }while(ch != EOF);
    }
    
    int main(){
      FILE *input = NULL;
      FILE *output = NULL;
      int k = 3;
    
      input = fopen("teste.txt", "r");
      output = fopen("teste_out.txt", "w");
      if(input == NULL || output == NULL){ //se deu erro
        printf("shit");
        return 1;
      }
    
      caesar_cipher(input, output, k); //encripta usando a chave k
      //caesar_cipher(input, output, k); //decripta usando a chave k
      
      fclose(input);
      fclose(output);
    
      return 0;
    }
    
    

    public by Drowze  280056  3  3  0

    Compress all files in a folder into individual 7z files

    Compress all files in a folder into individual 7z files: Compress_individual_files.txt
    FOR %i IN (*.*) DO 7z.exe a -m0=LZMA2 -mmt=x "%~ni.7z" "%i"
    
    where x = number of cores
    
    

    public by Rafael G  2432  0  3  0

    #estruturas_de_dados #listas_ligadas #snippets

    #estruturas_de_dados #listas_ligadas #snippets: listas_ligadas.c
    /*
    Algumas operações em listas ligadas podem variar para permitir a utilização de outros tipos de dados.
    As prinicipais variações são nos algoritmos de Inserção e no de Remoção.
    
    >As Inserções em Listas Ligadas podem ser, basicamente, das seguintes maneiras:
    - Inserir um elemento no Final da Lista
    - Inserir ume lemento no Início da Lista
    - Inserir um elemento em uma Lista Ordenada
    
    >Já a Remoção pode ser feita das formas:
    - Buscar um elemento e remover da lista
    - Remover o primeiro elemento
    - Remover o ultimo elemento
    */
    
    
    /*
    >>INSERÇÃO (InsereFinal)
    >Um novo nó é sempre inserido no final da Lista.
    >Se a lista está vazia:
    - Faz a lista apontar para um novo nó
    >Senão, procura o último elemento:
    - Faz o último elemento apontar para o novo nó.
    */
    
    //Inserção (InsereFinal)
    void InsereFim(lista *L, pno No){
        pno p = *L;
        if(p == NULL)
            *L = No;
        else {
            while(p->prox != NULL)
                p = p->prox;
            p->prox = No;
        }
    }
    
    //Inserção (InsereFinal - Recursivo)
    void InsereFim(lista *L, pno No){
        pno p = *L;
    
        if(p == NULL)
            *L = No;
        else
            InsereFim(&(p->prox), No);
    }
    
    /*
    >>INSERÇÃO (InsereInício)
    >Um novo nó é sempre inserido no inicio da Lista
    >Se a Lista está vazia:
    - Faz a lista apontar para o novo nó.
    >Senão:
    - Faz o nó apontar para o primeiro da Lista
    - Faz a Lista apontar para o novo nó
    */
    
    //Inserção (InsereInicio)
    void InsereInicio(lista *L, pno No){
        if(*L != NULL)
            No->prox = *L;
        *L = No;
    }
    
    /*
    >>INSERÇÃO (InsereOrdenado)
    >Insere um nó mantendo a lista ordenada
    >Se a Lista está vazia:
    - Faz a lista apontar para o novo nó
    >Se não, encontra o primeiro nó maior ou igual ao novo nó
    - Faz o nó apontar para o nó atual
    - Faz o anterior apontar para o novo nó
    */
    
    //Inserção (InsereOrdenado)
    void InsereOrdenado(lista *L, pno No){
        pno a = NULL, p = *L;
    
        if(p==NULL)
            *L = No;
        else{
            while(p != NULL && p->info > No->info){
                a = p;
                p = p->prox;
            }
            if(a == NULL){
                No->prox = *L;
                *L = No;
            }
            else {
                No->prox = p;
                a->prox = No;
            }
        }
    }
    
    //Inserção (InsereOrd Recursivo)
    void InsereOrdenado (lista *L, pno No){
        pno p = *L;
        if(p == NULL)
            *L = No;
        else if(p->info >= No->info){
            No->prox = p;
            *L = No;
        }
        else
            InsereOrdenado(&(p->prox), No);
    }
    
    /*
    >>REMOÇÃO (RemoveNo)
    >Remove o nó cuja informação é info.
    >Se a Lista está vazia, nada a fazer.
    >Se não, procura info
    - Guarda o endereço do nó a ser removido
    - Faz o nó anterior apontar para o próximo
    - Libera a memória
    */
    
    //Remoção (RemoveNo)
    void RemoveNo(lista *L, TipoDado Info){
        pno a = NULL, p = *L;
    
        while (p != NULL && p->info != Info){
            a = p;
            p = p->prox;
        }
        if(p != NULL){
            if(p->info == Info){
                if(a == NULL)
                    *L = p->prox;
                else
                    a->prox = p->prox;
                free(p);
            }
        }
    }
    
    //Remoção (RemoveNo - Recursivo)
    void RemoveNo(lista *L, TipoDado Info){
        pno p = *L;
        if(p != NULL){
            if(p->info == Info){
                *L = p->prox;
                free(p);
            }
            else RemoveNo(&(p-prox), Info);
        }
    }
    
    /*
    >>REMOÇÃO (RemovePrimeiro)
    >Neste caso, sempre o primeiro elemento dalista será removido
    >Se a Lista está vazia, nada a fazer.
    >Se não
    - Guarda o endereço do primeiro nó
    - Faz a lista apontar para o próximo
    - Libera a memória
    */
    
    //RemovePrimeiro
    void RemovePrimeiro(lista *L){
        pno p = *L;
    
        if(p != NULL){
            *L = p->prox;
            free(p);
        }
    }
    
    

    public by ghabs  129810  0  3  0

    Delete

    Delete: delete.js
    app.delete('/headline/:id', function(req, res) {
    headlines.splice(req.params.id, 1);
    res.json(204);
    });
    
    

    List Complete ( 7 snippets total )

    • Public Snippets
    • Channels Snippets